{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|default_exp data.validation"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Spliting data"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    ">Functions required to perform cross-validation and transform unique time series sequence into multiple samples ready to be used by a time series model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "from tsai.imports import *\n",
    "from imblearn.over_sampling import RandomOverSampler\n",
    "from imblearn.under_sampling import RandomUnderSampler\n",
    "from matplotlib.patches import Patch\n",
    "from matplotlib.colors import LinearSegmentedColormap\n",
    "from sklearn.model_selection import train_test_split, KFold, StratifiedKFold\n",
    "from fastcore.xtras import is_listy\n",
    "from tsai.utils import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def RandomSplitter(valid_pct=0.2, seed=None):\n",
    "    \"Create function that splits `items` between train/val with `valid_pct` randomly.\"\n",
    "    def _inner(o):\n",
    "        if seed is not None: torch.manual_seed(seed)\n",
    "        rand_idx = L(list(torch.randperm(len(o)).numpy()))\n",
    "        cut = int(valid_pct * len(o))\n",
    "        return rand_idx[cut:],rand_idx[:cut]\n",
    "    return _inner"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def check_overlap(a, b, c=None):\n",
    "    \"Checks if there's overlap between array-like objects\"\n",
    "    a = np.asarray(a).flatten()\n",
    "    b = np.asarray(b).flatten()\n",
    "    c = np.asarray(c).flatten() if c is not None else c\n",
    "    ab = np.isin(a, b)\n",
    "    ac = np.isin(a, c) if c is not None else np.array([False])\n",
    "    bc = np.isin(b, c) if c is not None else np.array([False])\n",
    "    if ab.sum() + ac.sum() + bc.sum() == 0: return False\n",
    "    if c is None: return L(a[ab].tolist())\n",
    "    return L(a[ab].tolist()), L(a[ac].tolist()), L(b[bc].tolist())\n",
    "\n",
    "def check_splits_overlap(splits):\n",
    "    return [check_overlap(*_splits) for _splits in splits] if is_listy(splits[0][0]) else check_overlap(*splits)\n",
    "\n",
    "def leakage_finder(*splits, verbose=True):\n",
    "    '''You can pass splits as a tuple, or train, valid, ...'''\n",
    "    splits = L(*splits)\n",
    "    overlaps = 0\n",
    "    for i in range(len(splits)):\n",
    "        for j in range(i + 1, len(splits)):\n",
    "            overlap = check_overlap(splits[i], splits[j])\n",
    "            if overlap:\n",
    "                pv(f'overlap between splits [{i}, {j}] {overlap}', verbose)\n",
    "                overlaps += 1\n",
    "    assert overlaps == 0, 'Please, review your splits!'\n",
    "\n",
    "def balance_idx(o, shuffle=False, strategy=\"oversample\", random_state=None, verbose=False):\n",
    "    assert strategy in [\"oversample\", \"undersample\"]\n",
    "    if isinstance(o, list): o = L(o)\n",
    "    idx_ = np.arange(len(o)).reshape(-1, 1)\n",
    "    if strategy == \"oversample\":\n",
    "        ros = RandomOverSampler(random_state=random_state)\n",
    "    elif strategy == \"undersample\":\n",
    "        ros = RandomUnderSampler(random_state=random_state)\n",
    "    resampled_idxs, _ = ros.fit_resample(idx_, np.asarray(o))\n",
    "    new_idx = L(resampled_idxs.reshape(-1,).tolist())\n",
    "    if shuffle: new_idx = random_shuffle(new_idx)\n",
    "    return new_idx"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.arange(10)\n",
    "b = np.arange(10, 20)\n",
    "test_eq(check_overlap(a, b), False)\n",
    "a = np.arange(10)\n",
    "b = np.arange(9, 20)\n",
    "test_eq(check_overlap(a, b), [9])\n",
    "a = np.arange(10)\n",
    "b = np.arange(10, 20)\n",
    "c = np.arange(20, 30)\n",
    "test_eq(check_overlap(a, b, c), False)\n",
    "a = np.arange(10)\n",
    "b = np.arange(10, 20)\n",
    "c = np.arange(10, 30)\n",
    "test_eq(check_overlap(a, b, c), ([], [], [10, 11, 12, 13, 14, 15, 16, 17, 18, 19]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "imbalanced:               [0 1 2 3 4] [24 43 64 41  8]\n",
      "balanced (oversample):    [0 1 2 3 4] [64 64 64 64 64]\n",
      "balanced (undersample):   [0 1 2 3 4] [8 8 8 8 8]\n"
     ]
    }
   ],
   "source": [
    "y = np.concatenate([[i] * np.random.randint(10, 100) for i in range(5)])\n",
    "train_split = np.random.choice(len(y), int(len(y) * .8), False)\n",
    "c, v = np.unique(y[train_split], return_counts=True)\n",
    "print(f\"{'imbalanced:':25} {c} {v}\")\n",
    "\n",
    "oversampled_train_split = train_split[balance_idx(y[train_split], strategy=\"oversample\")]\n",
    "osc, osv = np.unique(y[oversampled_train_split], return_counts=True)\n",
    "print(f\"{'balanced (oversample):':25} {osc} {osv}\")\n",
    "test_eq(osv, [max(v)] * len(v))\n",
    "\n",
    "undersampled_train_split = train_split[balance_idx(y[train_split], strategy=\"undersample\")]\n",
    "usc, usv = np.unique(y[undersampled_train_split], return_counts=True)\n",
    "print(f\"{'balanced (undersample):':25} {usc} {usv}\")\n",
    "test_eq(usv, [min(v)] * len(v))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = L(list(concat(np.zeros(5), np.ones(10)).astype(int)))\n",
    "balanced_idx = balance_idx(l)\n",
    "test_eq(np.mean(l[balanced_idx]), 0.5)\n",
    "test_eq(isinstance(balanced_idx, L), True)\n",
    "\n",
    "l = list(concat(np.zeros(5), np.ones(10)).astype(int))\n",
    "balanced_idx = balance_idx(l)\n",
    "test_eq(np.mean(L(l)[balanced_idx]), 0.5)\n",
    "test_eq(isinstance(balanced_idx, L), True)\n",
    "\n",
    "a = concat(np.zeros(5), np.ones(10)).astype(int)\n",
    "balanced_idx = balance_idx(a)\n",
    "test_eq(np.mean(a[balanced_idx]), 0.5)\n",
    "test_eq(isinstance(balanced_idx, L), True)\n",
    "\n",
    "t = concat(torch.zeros(5), torch.ones(10))\n",
    "balanced_idx = balance_idx(t, shuffle=True)\n",
    "test_eq(t[balanced_idx].mean(), 0.5)\n",
    "test_eq(isinstance(balanced_idx, L), True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b = np.arange(100_000), np.arange(100_000, 200_000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "soft_labels = True\n",
    "filter_pseudolabels = .5\n",
    "balanced_pseudolabels = True\n",
    "\n",
    "pseudolabels = torch.rand(1000, 3)\n",
    "pseudolabels = torch.softmax(pseudolabels, -1) if soft_labels else torch.argmax(pseudolabels, -1)\n",
    "hpl = torch.argmax(pseudolabels, -1) if soft_labels else pseudolabels\n",
    "\n",
    "if filter_pseudolabels and pseudolabels.ndim > 1:\n",
    "    error = 1 - pseudolabels.max(-1).values\n",
    "    filt_pl_idx = np.arange(len(error))[error < filter_pseudolabels]\n",
    "    filt_pl = pseudolabels[error < filter_pseudolabels]\n",
    "    assert len(filt_pl) > 0, 'no filtered pseudolabels'\n",
    "    filt_hpl = torch.argmax(filt_pl, -1)\n",
    "else:\n",
    "    filt_pl_idx = np.arange(len(pseudolabels))\n",
    "    filt_pl = filt_hpl = pseudolabels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pl_split = filt_pl_idx[balance_idx(filt_hpl)] if balanced_pseudolabels else filt_pl_idx\n",
    "test_eq(hpl[pl_split].float().mean(), np.mean(np.unique(hpl)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def TrainValidTestSplitter(n_splits:int=1, valid_size:Union[float, int]=0.2, test_size:Union[float, int]=0., train_only:bool=False,\n",
    "                           stratify:bool=True, balance:bool=False, strategy:str=\"oversample\", shuffle:bool=True,\n",
    "                           random_state:Union[None, int]=None, verbose:bool=False, **kwargs):\n",
    "    \"Split `items` into random train, valid (and test optional) subsets.\"\n",
    "\n",
    "    if not shuffle and stratify and not train_only:\n",
    "        pv('stratify set to False because shuffle=False. If you want to stratify set shuffle=True', verbose)\n",
    "        stratify = False\n",
    "\n",
    "    def _inner(o, **kwargs):\n",
    "        if stratify:\n",
    "            _, unique_counts = np.unique(o, return_counts=True)\n",
    "            if np.min(unique_counts) >= 2 and np.min(unique_counts) >= n_splits: stratify_ = stratify\n",
    "            elif np.min(unique_counts) < n_splits:\n",
    "                stratify_ = False\n",
    "                pv(f'stratify set to False as n_splits={n_splits} cannot be greater than the min number of members in each class ({np.min(unique_counts)}).',\n",
    "                   verbose)\n",
    "            else:\n",
    "                stratify_ = False\n",
    "                pv('stratify set to False as the least populated class in o has only 1 member, which is too few.', verbose)\n",
    "        else: stratify_ = False\n",
    "        vs = 0 if train_only else 1. / n_splits if n_splits > 1 else int(valid_size * len(o)) if isinstance(valid_size, float) else valid_size\n",
    "        if test_size:\n",
    "            ts = int(test_size * len(o)) if isinstance(test_size, float) else test_size\n",
    "            train_valid, test = train_test_split(range(len(o)), test_size=ts, stratify=o if stratify_ else None, shuffle=shuffle,\n",
    "                                                 random_state=random_state, **kwargs)\n",
    "            test = toL(test)\n",
    "            if shuffle: test = random_shuffle(test, random_state)\n",
    "            if vs == 0:\n",
    "                train, _ = RandomSplitter(0, seed=random_state)(o[train_valid])\n",
    "                train = toL(train)\n",
    "                if balance: train = train[balance_idx(o[train], random_state=random_state, strategy=strategy)]\n",
    "                if shuffle: train = random_shuffle(train, random_state)\n",
    "                train_ = L(L([train]) * n_splits) if n_splits > 1 else train\n",
    "                valid_ = L(L([train]) * n_splits) if n_splits > 1 else train\n",
    "                test_ = L(L([test]) * n_splits) if n_splits > 1 else test\n",
    "                if n_splits > 1:\n",
    "                    return [split for split in itemify(train_, valid_, test_)]\n",
    "                else:\n",
    "                    return train_, valid_, test_\n",
    "            elif n_splits > 1:\n",
    "                if stratify_:\n",
    "                    splits = StratifiedKFold(n_splits=n_splits, shuffle=shuffle, random_state=random_state).split(np.arange(len(train_valid)), o[train_valid])\n",
    "                else:\n",
    "                    splits = KFold(n_splits=n_splits, shuffle=shuffle, random_state=random_state).split(np.arange(len(train_valid)))\n",
    "                train_, valid_ = L([]), L([])\n",
    "                for train, valid in splits:\n",
    "                    train, valid = toL(train), toL(valid)\n",
    "                    if balance: train = train[balance_idx(o[train], random_state=random_state, strategy=strategy)]\n",
    "                    if shuffle:\n",
    "                        train = random_shuffle(train, random_state)\n",
    "                        valid = random_shuffle(valid, random_state)\n",
    "                    train_.append(L(L(train_valid)[train]))\n",
    "                    valid_.append(L(L(train_valid)[valid]))\n",
    "                test_ = L(L([test]) * n_splits)\n",
    "                return [split for split in itemify(train_, valid_, test_)]\n",
    "            else:\n",
    "                train, valid = train_test_split(range(len(train_valid)), test_size=vs, random_state=random_state,\n",
    "                                                stratify=o[train_valid] if stratify_ else None, shuffle=shuffle, **kwargs)\n",
    "                train, valid = toL(train), toL(valid)\n",
    "                if balance: train = train[balance_idx(o[train], random_state=random_state, strategy=strategy)]\n",
    "                if shuffle:\n",
    "                    train = random_shuffle(train, random_state)\n",
    "                    valid = random_shuffle(valid, random_state)\n",
    "                return (L(L(train_valid)[train]), L(L(train_valid)[valid]),  test)\n",
    "        else:\n",
    "            if vs == 0:\n",
    "                train, _ = RandomSplitter(0, seed=random_state)(o)\n",
    "                train = toL(train)\n",
    "                if balance: train = train[balance_idx(o[train], random_state=random_state, strategy=strategy)]\n",
    "                if shuffle: train = random_shuffle(train, random_state)\n",
    "                train_ = L(L([train]) * n_splits) if n_splits > 1 else train\n",
    "                valid_ = L(L([train]) * n_splits) if n_splits > 1 else train\n",
    "                if n_splits > 1:\n",
    "                    return [split for split in itemify(train_, valid_)]\n",
    "                else:\n",
    "                    return (train_, valid_)\n",
    "            elif n_splits > 1:\n",
    "                if stratify_: splits = StratifiedKFold(n_splits=n_splits, shuffle=shuffle, random_state=random_state).split(np.arange(len(o)), o)\n",
    "                else: splits = KFold(n_splits=n_splits, shuffle=shuffle, random_state=random_state).split(np.arange(len(o)))\n",
    "                train_, valid_ = L([]), L([])\n",
    "                for train, valid in splits:\n",
    "                    train, valid = toL(train), toL(valid)\n",
    "                    if balance: train = train[balance_idx(o[train], random_state=random_state, strategy=strategy)]\n",
    "                    if shuffle:\n",
    "                        train = random_shuffle(train, random_state)\n",
    "                        valid = random_shuffle(valid, random_state)\n",
    "                    if not isinstance(train, (list, L)):  train = train.tolist()\n",
    "                    if not isinstance(valid, (list, L)):  valid = valid.tolist()\n",
    "                    train_.append(L(train))\n",
    "                    valid_.append(L(L(valid)))\n",
    "                return [split for split in itemify(train_, valid_)]\n",
    "            else:\n",
    "                train, valid = train_test_split(range(len(o)), test_size=vs, random_state=random_state, stratify=o if stratify_ else None,\n",
    "                                                shuffle=shuffle, **kwargs)\n",
    "                train, valid = toL(train), toL(valid)\n",
    "                if balance: train = train[balance_idx(o[train], random_state=random_state, strategy=strategy)]\n",
    "                return train, valid\n",
    "    return _inner"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def plot_splits(splits):\n",
    "    _max = 0\n",
    "    _splits = 0\n",
    "    for i, split in enumerate(splits):\n",
    "        if is_listy(split[0]):\n",
    "            for j, s in enumerate(split):\n",
    "                _max = max(_max, array(s).max())\n",
    "                _splits += 1\n",
    "        else:\n",
    "            _max = max(_max, array(split).max())\n",
    "            _splits += 1\n",
    "    _splits = [splits] if not is_listy(split[0]) else splits\n",
    "    v = np.zeros((len(_splits), _max + 1))\n",
    "    for i, split in enumerate(_splits):\n",
    "        if is_listy(split[0]):\n",
    "            for j, s in enumerate(split):\n",
    "                v[i, s] = 1 + j\n",
    "        else: v[i, split] = 1 + i\n",
    "    vals = np.unique(v)\n",
    "    if 2 in vals and 3 not in vals:\n",
    "        vals = [v + 1 if v == 2 else v for v in vals]\n",
    "    plt.figure(figsize=(16, len(_splits)/2))\n",
    "    if len(vals) == 1:\n",
    "        v = np.ones((len(_splits), _max + 1))\n",
    "        plt.pcolormesh(v, color='blue')\n",
    "        legend_elements = [Patch(facecolor='blue', label='Train')]\n",
    "        plt.legend(handles=legend_elements, bbox_to_anchor=(1.05, 1), loc='upper left')\n",
    "    else:\n",
    "        colors = L(['gainsboro', 'blue', 'orange', 'limegreen'])[vals]\n",
    "        cmap = LinearSegmentedColormap.from_list('', colors)\n",
    "        plt.pcolormesh(v, cmap=cmap)\n",
    "        legend_elements = L([\n",
    "            Patch(facecolor='gainsboro', label='None'),\n",
    "            Patch(facecolor='blue', label='Train'),\n",
    "            Patch(facecolor='orange', label='Valid'),\n",
    "            Patch(facecolor='limegreen', label='Test')])[vals]\n",
    "        plt.legend(handles=legend_elements, bbox_to_anchor=(1.05, 1), loc='upper left')\n",
    "    plt.title('Split distribution')\n",
    "    plt.yticks(ticks=np.arange(.5, len(_splits)+.5, 1.0), labels=np.arange(1, len(_splits)+1, 1.0).astype(int))\n",
    "    plt.gca().invert_yaxis()\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def get_splits(o, n_splits:int=1, valid_size:float=0.2, test_size:float=0., train_only:bool=False, train_size:Union[None, float, int]=None, balance:bool=False,\n",
    "               strategy:str=\"oversample\", shuffle:bool=True, stratify:bool=True, check_splits:bool=True, random_state:Union[None, int]=None,\n",
    "               show_plot:bool=True, verbose:bool=False):\n",
    "    '''Arguments:\n",
    "        o            : object to which splits will be applied, usually target.\n",
    "        n_splits     : number of folds. Must be an int >= 1.\n",
    "        valid_size   : size of validation set. Only used if n_splits = 1. If n_splits > 1 valid_size = (1. - test_size) / n_splits.\n",
    "        test_size    : size of test set. Default = 0.\n",
    "        train_only   : if True valid set == train set. This may be useful for debugging purposes.\n",
    "        train_size   : size of the train set used. Default = None (the remainder after assigning both valid and test).\n",
    "                        Useful for to get learning curves with different train sizes or get a small batch to debug a neural net.\n",
    "        balance      : whether to balance data so that train always contain the same number of items per class.\n",
    "        strategy     : strategy to balance data (\"undersample\" or \"oversample\"). Default = \"oversample\".\n",
    "        shuffle      : whether to shuffle data before splitting into batches. Note that the samples within each split will be shuffle.\n",
    "        stratify     : whether to create folds preserving the percentage of samples for each class.\n",
    "        check_splits : whether to perform leakage and completion checks.\n",
    "        random_state : when shuffle is True, random_state affects the ordering of the indices. Pass an int for reproducible output.\n",
    "        show_plot    : plot the split distribution\n",
    "    '''\n",
    "    if n_splits == 1 and valid_size == 0. and  test_size == 0.: train_only = True\n",
    "    if balance: stratify = True\n",
    "    splits = TrainValidTestSplitter(n_splits, valid_size=valid_size, test_size=test_size, train_only=train_only, stratify=stratify,\n",
    "                                    balance=balance, strategy=strategy, shuffle=shuffle, random_state=random_state, verbose=verbose)(o)\n",
    "    if check_splits:\n",
    "        if train_only or (n_splits == 1 and valid_size == 0): print('valid == train')\n",
    "        elif n_splits > 1:\n",
    "            for i in range(n_splits):\n",
    "                leakage_finder([*splits[i]], verbose=True)\n",
    "                cum_len = 0\n",
    "                for split in splits[i]: cum_len += len(split)\n",
    "                if not balance: assert len(o) == cum_len, f'len(o)={len(o)} while cum_len={cum_len}'\n",
    "        else:\n",
    "            leakage_finder([splits], verbose=True)\n",
    "            cum_len = 0\n",
    "            if not isinstance(splits[0], Integral):\n",
    "                for split in splits: cum_len += len(split)\n",
    "            else: cum_len += len(splits)\n",
    "            if not balance: assert len(o) == cum_len, f'len(o)={len(o)} while cum_len={cum_len}'\n",
    "    if train_size is not None and train_size != 1: # train_size=1 legacy\n",
    "        if n_splits > 1:\n",
    "            splits = list(splits)\n",
    "            for i in range(n_splits):\n",
    "                splits[i] = list(splits[i])\n",
    "                if isinstance(train_size, Integral):\n",
    "                    n_train_samples = train_size\n",
    "                elif train_size > 0 and train_size < 1:\n",
    "                    n_train_samples = int(len(splits[i][0]) * train_size)\n",
    "                splits[i][0] = L(random_choice(splits[i][0], n_train_samples, False).tolist())\n",
    "                if train_only:\n",
    "                    if valid_size != 0: splits[i][1] = splits[i][0]\n",
    "                    if test_size != 0: splits[i][2] = splits[i][0]\n",
    "                splits[i] = tuple(splits[i])\n",
    "            splits = tuple(splits)\n",
    "        else:\n",
    "            splits = list(splits)\n",
    "            if isinstance(train_size, Integral):\n",
    "                n_train_samples = train_size\n",
    "            elif train_size > 0 and train_size < 1:\n",
    "                n_train_samples = int(len(splits[0]) * train_size)\n",
    "            splits[0] = L(random_choice(splits[0], n_train_samples, False).tolist())\n",
    "            if train_only:\n",
    "                if valid_size != 0: splits[1] = splits[0]\n",
    "                if test_size != 0: splits[2] = splits[0]\n",
    "            splits = tuple(splits)\n",
    "    if show_plot: plot_splits(splits)\n",
    "    return splits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x250 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "(((#5000) [3490,2428,4475,8317,2802,6834,2954,7671,3383,9554...],\n",
       "  (#1600) [1680,6677,5879,4428,5511,8312,372,5127,7012,3021...],\n",
       "  (#2000) [1263,6498,1602,1838,1073,5304,1210,1037,8789,6175...]),\n",
       " ((#5000) [3442,4237,470,3901,3808,3793,6286,8546,6254,9530...],\n",
       "  (#1600) [9160,5451,3628,143,2054,7225,7124,8057,1405,5089...],\n",
       "  (#2000) [1263,6498,1602,1838,1073,5304,1210,1037,8789,6175...]),\n",
       " ((#5000) [9850,7451,7338,9742,3258,1527,4450,5678,2932,1693...],\n",
       "  (#1600) [6186,5970,376,7848,3786,1663,7193,3647,3277,553...],\n",
       "  (#2000) [1263,6498,1602,1838,1073,5304,1210,1037,8789,6175...]),\n",
       " ((#5000) [1853,7308,7375,3851,1852,3820,2601,3868,8718,7190...],\n",
       "  (#1600) [4182,6419,6265,4837,168,9627,2500,9951,1610,7547...],\n",
       "  (#2000) [1263,6498,1602,1838,1073,5304,1210,1037,8789,6175...]),\n",
       " ((#5000) [7878,6392,453,4817,4676,5738,6482,4033,8114,7337...],\n",
       "  (#1600) [7682,6416,2877,9164,1583,342,2916,4806,8776,2046...],\n",
       "  (#2000) [1263,6498,1602,1838,1073,5304,1210,1037,8789,6175...]))"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n_splits                = 5\n",
    "valid_size              = 0.2\n",
    "test_size               = 0.2\n",
    "train_only              = False  # set to True for debugging (valid = train)\n",
    "train_size              = 5000\n",
    "stratify                = True\n",
    "balance                 = False\n",
    "shuffle                 = True\n",
    "predefined_splits       = None\n",
    "show_plot               = True\n",
    "\n",
    "\n",
    "check_splits = True\n",
    "random_state = 23\n",
    "\n",
    "y = np.random.randint(0, 3, 10000) + 100\n",
    "\n",
    "splits = get_splits(y, n_splits=n_splits, valid_size=valid_size, test_size=test_size, shuffle=shuffle, balance=balance, stratify=stratify,\n",
    "                    train_only=train_only, train_size=train_size, check_splits=check_splits, random_state=random_state, show_plot=show_plot, verbose=True)\n",
    "splits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "valid == train\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x50 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "((#256) [550,813,388,595,948,198,354,749,175,812...],\n",
       " (#256) [550,813,388,595,948,198,354,749,175,812...])"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_size=256\n",
    "y = np.random.randint(0, 3, 1000) + 100\n",
    "splits = get_splits(y, train_size=train_size, train_only=True)\n",
    "test_eq(splits[0], splits[1])\n",
    "test_eq(len(splits[0]), train_size)\n",
    "splits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def get_walk_forward_splits(\n",
    "    o, # 3D object with shape [samples x features x steps] containing the time series we need to split\n",
    "    n_splits=1, # # of splits\n",
    "    train_size=None, # optional: training set size as an int or a float. None when using and anchored strategy.\n",
    "    valid_size=0.2, # validation set size as an int or a float\n",
    "    test_size=0., # test set size as an int or a float\n",
    "    anchored = False, # starting point for train set remains the same for all splits\n",
    "    gap = 0., # # of samples to exclude from the end of each train set before the validation set. Entered as an int or a float\n",
    "    test_after_valid = True, # flag to indicate if validation and test will be samples randomly or sequentially\n",
    "    random_state = None, # integer that can be used to generate reproducible results\n",
    "    show_plot=True, # plots the splits created\n",
    "):\n",
    "\n",
    "    if anchored:\n",
    "        train_size = None\n",
    "    elif isinstance(train_size, float):\n",
    "        train_size = np.int32(np.floor(len(o) * train_size))\n",
    "    if isinstance(valid_size, float):\n",
    "        valid_size = np.int32(np.floor(len(o) * valid_size))\n",
    "    if isinstance(test_size, float):\n",
    "        test_size = np.int32(np.floor(len(o) * test_size))\n",
    "    if isinstance(gap, float):\n",
    "        gap = np.int32(np.floor(len(o) * gap))\n",
    "\n",
    "    if train_size is not None:\n",
    "        assert train_size + (valid_size + test_size + gap) * n_splits <= len(o), \"reduce train_size, valid_size, test_size, gap or n_splits\"\n",
    "    else:\n",
    "        assert (valid_size + test_size + gap) * n_splits < len(o), \"reduce valid_size, test_size, gap or n_splits\"\n",
    "\n",
    "    if not test_after_valid:\n",
    "        assert valid_size == test_size\n",
    "\n",
    "    train_idxs = []\n",
    "    valid_idxs = []\n",
    "    test_idxs = []\n",
    "\n",
    "    end = 0\n",
    "    all_idxs = np.arange(len(o))\n",
    "    for n in range(n_splits):\n",
    "        if valid_size > 0 and test_size > 0:\n",
    "            if test_after_valid:\n",
    "                test_idxs.append(L(all_idxs[-test_size:].tolist()))\n",
    "                all_idxs = all_idxs[:-test_size]\n",
    "                valid_idxs.append(L(all_idxs[-valid_size:].tolist()))\n",
    "                all_idxs = all_idxs[:-valid_size]\n",
    "                if gap > 0:\n",
    "                    all_idxs = all_idxs[:-gap]\n",
    "                if anchored:\n",
    "                    train_idxs.append(L(all_idxs.tolist()))\n",
    "                else:\n",
    "                    train_idxs.append(L(all_idxs[-train_size:].tolist()))\n",
    "            else:\n",
    "                valid_test_idxs = all_idxs[-test_size - valid_size:]\n",
    "                np.random.seed(random_state)\n",
    "                valid_test_idxs = np.random.permutation(valid_test_idxs)\n",
    "                valid_idxs.append(L(valid_test_idxs[:valid_size]))\n",
    "                test_idxs.append(L(valid_test_idxs[valid_size:]))\n",
    "                all_idxs = all_idxs[:-test_size - valid_size]\n",
    "                if gap > 0:\n",
    "                    all_idxs = all_idxs[:-gap]\n",
    "                if anchored:\n",
    "                    train_idxs.append(L(all_idxs.tolist()))\n",
    "                else:\n",
    "                    train_idxs.append(L(all_idxs[-train_size:].tolist()))\n",
    "        elif valid_size > 0:\n",
    "            valid_idxs.append(L(all_idxs[-valid_size:].tolist()))\n",
    "            all_idxs = all_idxs[:-valid_size]\n",
    "            test_idxs.append(L([]))\n",
    "            if gap > 0:\n",
    "                all_idxs = all_idxs[:-gap]\n",
    "            if anchored:\n",
    "                train_idxs.append(L(all_idxs.tolist()))\n",
    "            else:\n",
    "                train_idxs.append(L(all_idxs[-train_size:].tolist()))\n",
    "\n",
    "    splits = []\n",
    "    for n in range(n_splits):\n",
    "        if valid_size > 0 and test_size > 0:\n",
    "            splits.append((L(train_idxs[n]), L(valid_idxs[n]), L(test_idxs[n])))\n",
    "        elif valid_size > 0:\n",
    "            splits.append((L(train_idxs[n]), L(valid_idxs[n])))\n",
    "        else:\n",
    "            splits.append((L(train_idxs[n]),))\n",
    "    splits = tuple(splits)[::-1]\n",
    "    if show_plot:\n",
    "        plot_splits(splits)\n",
    "    return splits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x200 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x150 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "o = np.random.rand(10_000, 3,  50) # shape: [samples x features x steps]\n",
    "\n",
    "splits = get_walk_forward_splits(\n",
    "    o,\n",
    "    n_splits=4,\n",
    "    train_size=.6,\n",
    "    valid_size=0.1,\n",
    "    test_size=0.1,\n",
    "    anchored = True,\n",
    "    gap = 100,\n",
    "    test_after_valid = True,\n",
    "    random_state = None,\n",
    "    show_plot=True,\n",
    ")\n",
    "\n",
    "splits = get_walk_forward_splits(\n",
    "    o,\n",
    "    n_splits=3,\n",
    "    train_size=0.3,\n",
    "    valid_size=0.1,\n",
    "    test_size=0.1,\n",
    "    anchored = False,\n",
    "    gap = 0.,\n",
    "    test_after_valid = False,\n",
    "    random_state = None,\n",
    "    show_plot=True,\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def TSSplitter(\n",
    "    valid_size=0.2, # int or float indicating the validation set size\n",
    "    test_size=0., # int or float indicating the test set size\n",
    "    fcst_horizon=0, # int that indicates the number of time steps removed at the end of train (and validation)\n",
    "    show_plot=True, # flag that indicates if a plot showing the splits will be created\n",
    "):\n",
    "    \"Create function that splits `items` between train/val with `valid_size` without shuffling data.\"\n",
    "\n",
    "    if fcst_horizon:\n",
    "        fcst_horizon = fcst_horizon - 1\n",
    "\n",
    "    def _inner(o):\n",
    "        valid_cut = valid_size if isinstance(valid_size, Integral) else round(valid_size * len(o))\n",
    "        if test_size:\n",
    "            test_cut = test_size if isinstance(test_size, Integral) else round(test_size * len(o))\n",
    "        else:\n",
    "            test_cut = 0\n",
    "        idx = np.arange(len(o), dtype=smallest_dtype(len(o)))\n",
    "        if test_size:\n",
    "            if len(idx) < 1_000_000:\n",
    "                splits = (L(idx[:-valid_cut - test_cut - fcst_horizon].tolist()),\n",
    "                          L(idx[-valid_cut - test_cut: - test_cut - fcst_horizon].tolist()),\n",
    "                          L(idx[-test_cut:].tolist()))\n",
    "            else:\n",
    "                splits = (idx[:-valid_cut - test_cut - fcst_horizon],\n",
    "                          idx[-valid_cut - test_cut: - test_cut - fcst_horizon],\n",
    "                          idx[-test_cut:])\n",
    "        else:\n",
    "            if len(idx) < 1_000_000:\n",
    "                splits = (L(idx[:-valid_cut - fcst_horizon].tolist()), L(idx[-valid_cut:].tolist()))\n",
    "            else:\n",
    "                splits = (idx[:-valid_cut - fcst_horizon], idx[-valid_cut:])\n",
    "        if show_plot:\n",
    "            if len(o) > 1_000_000:\n",
    "                warnings.warn('the splits are too large to be plotted')\n",
    "            else:\n",
    "                plot_splits(splits) if test_size else plot_splits(splits[:2])\n",
    "        return splits\n",
    "    return _inner\n",
    "\n",
    "TimeSplitter = TSSplitter"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x50 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x50 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x50 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x50 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "((#800) [0,1,2,3,4,5,6,7,8,9...],\n",
       " (#200) [800,801,802,803,804,805,806,807,808,809...])"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = np.arange(1000) + 100\n",
    "test_eq(TimeSplitter(valid_size=0.2)(y)[1], L(np.arange(800, 1000).tolist()))\n",
    "test_eq(TimeSplitter(valid_size=0.2)(y)[0], TimeSplitter(valid_size=200)(y)[0])\n",
    "TimeSplitter(valid_size=0.2, show_plot=True)(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "stratify set to False as n_splits=5 cannot be greater than the min number of members in each class (1).\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x250 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "(601.11, (#800) [314,194,782,789,502,917,137,415,904,181...])"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n_splits                = 5\n",
    "valid_size              = 0.2\n",
    "test_size               = 0\n",
    "train_only              = False  # set to True for debugging (valid = train)\n",
    "train_size              = None\n",
    "stratify                = True\n",
    "balance                 = True\n",
    "shuffle                 = True\n",
    "predefined_splits       = None\n",
    "show_plot               = True\n",
    "\n",
    "\n",
    "check_splits = True\n",
    "random_state = 23\n",
    "\n",
    "splits = get_splits(y, n_splits=n_splits, valid_size=valid_size, test_size=test_size, shuffle=shuffle, balance=balance, stratify=stratify,\n",
    "                    train_only=train_only, train_size=train_size, check_splits=check_splits, random_state=random_state, show_plot=show_plot, verbose=True)\n",
    "split = splits[0] if n_splits == 1 else splits[0][0]\n",
    "y[split].mean(), split"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[((#800) [314,194,782,789,502,917,137,415,904,181...],\n",
       "  (#200) [362,151,934,378,95,597,500,117,980,844...]),\n",
       " ((#800) [312,198,777,788,515,910,145,413,898,186...],\n",
       "  (#200) [352,133,955,396,64,596,442,79,991,882...]),\n",
       " ((#800) [311,197,783,791,507,922,145,416,908,184...],\n",
       "  (#200) [338,125,912,361,54,594,486,88,994,859...]),\n",
       " ((#800) [296,181,782,789,493,917,130,401,905,165...],\n",
       "  (#200) [405,199,953,444,113,610,515,137,997,881...]),\n",
       " ((#800) [320,190,782,788,506,906,141,412,893,178...],\n",
       "  (#200) [336,149,942,358,49,582,472,70,990,907...])]"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list([splits[0], splits[1], splits[2], splits[3], splits[4]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "stratify set to False as n_splits=5 cannot be greater than the min number of members in each class (1).\n",
      "valid == train\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x250 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_splits = 5\n",
    "valid_size = 0.\n",
    "test_size = 0.\n",
    "shuffle = True\n",
    "stratify = True\n",
    "train_only = True\n",
    "train_size = None\n",
    "check_splits = True\n",
    "random_state = 1\n",
    "show_plot = True\n",
    "\n",
    "splits = get_splits(y, n_splits=n_splits, valid_size=valid_size, test_size=test_size, shuffle=shuffle, stratify=stratify,\n",
    "                    train_only=train_only, train_size=train_size, check_splits=check_splits, random_state=random_state, show_plot=show_plot, verbose=True)\n",
    "for split in splits:\n",
    "    test_eq(len(split[0]), len(y))\n",
    "    test_eq(np.sort(split[0]), np.arange(len(y)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x250 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x250 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_splits = 5\n",
    "y = np.random.randint(0, 2, 1000)\n",
    "\n",
    "splits = get_splits(y, n_splits=n_splits, shuffle=False, check_splits=True)\n",
    "test_eq(np.concatenate((L(zip(*splits))[1])), np.arange(len(y)))\n",
    "\n",
    "splits = get_splits(y, n_splits=n_splits, shuffle=True, check_splits=True)\n",
    "test_eq(np.sort(np.concatenate((L(zip(*splits))[1]))), np.arange(len(y)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x100 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "n_splits = 2\n",
    "y = np.random.randint(0, 2, 1000)\n",
    "\n",
    "splits = get_splits(y, n_splits=n_splits, test_size=0.2, shuffle=False)\n",
    "for i in range(n_splits): leakage_finder(*splits[i])\n",
    "test_eq(len(splits), n_splits)\n",
    "test_eq(len(splits[0]), 3)\n",
    "s = []\n",
    "[s.extend(split) for split in splits[0]]\n",
    "test_eq(np.sort(s), np.arange(len(y)))\n",
    "s = []\n",
    "[s.extend(split) for split in splits[1]]\n",
    "test_eq(np.sort(s), np.arange(len(y)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x50 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x50 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x50 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x50 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "y = np.random.randint(0, 2, 1000)\n",
    "splits1 = get_splits(y, valid_size=.25, test_size=0, random_state=23, stratify=True, shuffle=True)\n",
    "splits2 = get_splits(y, valid_size=.25, test_size=0, random_state=23, stratify=True, shuffle=True)\n",
    "splits3 = get_splits(y, valid_size=.25, test_size=0, random_state=None, stratify=True, shuffle=True)\n",
    "splits4 = get_splits(y, valid_size=.25, test_size=0, random_state=None, stratify=True, shuffle=True)\n",
    "test_eq(splits1[0], splits2[0])\n",
    "test_ne(splits3[0], splits4[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x50 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "y = np.random.randint(0, 2, 100)\n",
    "splits = get_splits(y, valid_size=.25, test_size=0, random_state=23, stratify=True, shuffle=True)\n",
    "test_eq(len(splits), 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x50 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "y = np.random.randint(0, 2, 100)\n",
    "splits = get_splits(y, valid_size=.25, test_size=0, random_state=23, stratify=True)\n",
    "test_eq(len(splits), 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x50 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "y = np.random.randint(0, 2, 100)\n",
    "splits = get_splits(y, valid_size=.25, test_size=20, random_state=23, stratify=True)\n",
    "test_eq(len(splits), 3)\n",
    "leakage_finder(*splits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "splits = TrainValidTestSplitter(valid_size=.25, test_size=20, random_state=23, stratify=True)(np.random.randint(0, 2, 100))\n",
    "test_eq(len(splits[1]), 25)\n",
    "test_eq(len(splits[2]), 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABZcAAABoCAYAAACNDM73AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAh7klEQVR4nO3deXQUVdrH8V9n6xBCEiIhASQEMaKyiSwxCoqHJUHHUXAD0QF1QGWXARVfDQFRFJTjgKigZ8QzojA4rghoBA2iUXYQQUBIIAoIKjGELdt9/3DSpknT3dV0OiZ+P+f0IV116z5PVdetqn5OUW0zxhgBAAAAAAAAAGBBUE0nAAAAAAAAAACofSguAwAAAAAAAAAso7gMAAAAAAAAALCM4jIAAAAAAAAAwDKKywAAAAAAAAAAyyguAwAAAAAAAAAso7gMAAAAAAAAALCM4jIAAAAAAAAAwDKKywAAAAAAAAAAyyguAwAAVJP58+fLZrMpLy/PMa1Hjx7q0aOH32NlZmbKZrM5TUtKStKQIUP8Hut0eXl5stlsmj9/vmPakCFDFBkZWe2xK9hsNmVmZgYsHgAAAACKywAAAA5ff/21brrpJrVo0ULh4eFq1qyZevfurdmzZ1dbzP379yszM1ObNm2qthhWLF269A9bpP0j5wYAAAD8GYXUdAIAAAB/BF988YWuvvpqJSYmaujQoUpISFB+fr6+/PJL/fOf/9SoUaP8Euejjz5yer9//35NnjxZSUlJuuSSS/wSo8KOHTsUFGTtXoKlS5dqzpw5loq4LVq00IkTJxQaGmoxQ2vc5XbixAmFhHBpCwAAAAQSV+AAAACSHn/8cUVHR2vt2rWKiYlxmnfo0CG/xQkLC/NbX57Y7fZq7b+0tFTl5eUKCwtTeHh4tcbypKbjAwAAAH9GPBYDAABA0u7du9WmTZsqhWVJaty4sdN7m82mkSNHasGCBWrdurXCw8PVqVMnrVq1ymOcys9c/vTTT9WlSxdJ0p133imbzVbl2cWurF69Wl26dFF4eLhatWqluXPnumx3+jOXS0pKNHnyZCUnJys8PFznnHOOunXrpqysLEm/PSd5zpw5jnWseEm/P1f56aef1rPPPqtWrVrJbrdr27ZtLp+5XGHPnj1KS0tT/fr11bRpU02ZMkXGGMf8Tz/9VDabTZ9++qnTcqf36S63immn39G8ceNG9e3bV1FRUYqMjFTPnj315ZdfOrWpeC72559/rnHjxikuLk7169dXv379dPjwYdcfAAAAAABJ3LkMAAAg6bdHO+Tk5Gjr1q1q27atx/bZ2dlatGiRRo8eLbvdrueff17p6elas2aNV8tL0kUXXaQpU6YoIyNDw4YNU/fu3SVJl19++RmX+frrr9WnTx/FxcUpMzNTpaWlmjRpkuLj4z3Gy8zM1LRp0/T3v/9dXbt2VWFhodatW6cNGzaod+/euueee7R//35lZWXp3//+t8s+XnnlFZ08eVLDhg2T3W5XbGysysvLXbYtKytTenq6LrvsMk2fPl3Lly/XpEmTVFpaqilTpnixhX7nTW6VffPNN+revbuioqL0wAMPKDQ0VHPnzlWPHj2UnZ2tlJQUp/ajRo1Sw4YNNWnSJOXl5enZZ5/VyJEjtWjRIkt5AgAAAH8mFJcBAAAkjR8/Xn379tUll1yirl27qnv37urZs6euvvpql88S3rp1q9atW6dOnTpJkgYMGKDWrVsrIyNDb731llcx4+Pj1bdvX2VkZCg1NVW33367x2UyMjJkjNFnn32mxMRESdKNN96odu3aeVz2gw8+0DXXXKN58+a5nJ+amqoLLrhAWVlZZ8zl+++/13fffae4uDjHtLy8PJdtT548qfT0dM2aNUuSNHz4cF133XV66qmnNHr0aDVq1MhjzlZyq+yRRx5RSUmJVq9erfPOO0+S9Le//U2tW7fWAw88oOzsbKf255xzjj766CPH3dDl5eWaNWuWfv31V0VHR3udJwAAAPBnwmMxAAAAJPXu3Vs5OTn661//qs2bN2v69OlKS0tTs2bN9N5771Vpn5qa6igsS1JiYqKuv/56ffjhhyorK6uWHMvKyvThhx/qhhtucBSWpd/ugE5LS/O4fExMjL755hvt2rXL5xxuvPFGp8KyJyNHjnT8XfE4keLiYn388cc+5+BJWVmZPvroI91www2OwrIkNWnSRLfddptWr16twsJCp2WGDRvm9JiN7t27q6ysTHv37q22PAEAAIDajuIyAADA/3Tp0kVvvfWWjhw5ojVr1mjixIk6evSobrrpJm3bts2pbXJycpXlL7jgAh0/frzantV7+PBhnThxwmXs1q1be1x+ypQpKigo0AUXXKB27dppwoQJ2rJli6UcWrZs6XXboKAgp+Ku9Ns2ks58t7M/HD58WMePH3e5TS666CKVl5crPz/faXrlYr0kNWzYUJJ05MiRassTAAAAqO0oLgMAAJwmLCxMXbp00RNPPKEXXnhBJSUlWrx4cU2nddauvPJK7d69W//617/Utm1bvfzyy7r00kv18ssve91HvXr1/JpT5buFK6uuu7/PJDg42OX0yj8+CAAAAMAZxWUAAAA3OnfuLEk6cOCA03RXj5bYuXOnIiIiLD024kzFVVfi4uJUr149l7F37NjhVR+xsbG688479cYbbyg/P1/t27dXZmamT/l4Ul5erj179jhN27lzpyQpKSlJ0u93CBcUFDi1c/U4Cm9zi4uLU0REhMtt8u233yooKEjNmzf3qi8AAAAAZ0ZxGQAAQNInn3zi8i7VpUuXSqr62ImcnBxt2LDB8T4/P1/vvvuu+vTpc8a7YF2pX7++pKrFVVeCg4OVlpamd955R/v27XNM3759uz788EOPy//8889O7yMjI3X++efr1KlTPuXjjeeee87xtzFGzz33nEJDQ9WzZ09JUosWLRQcHKxVq1Y5Lff8889X6cvb3IKDg9WnTx+9++67To/f+PHHH/X666+rW7duioqK8nGNAAAAAFQIqekEAAAA/ghGjRql48ePq1+/frrwwgtVXFysL774QosWLVJSUpLuvPNOp/Zt27ZVWlqaRo8eLbvd7iiGTp482VLcVq1aKSYmRi+++KIaNGig+vXrKyUl5YzPNp48ebKWL1+u7t27a/jw4SotLdXs2bPVpk0bj89Pvvjii9WjRw916tRJsbGxWrdund58802nH92r+JHC0aNHKy0tTcHBwRowYICldaoQHh6u5cuXa/DgwUpJSdGyZcv0wQcf6OGHH3bc3R0dHa2bb75Zs2fPls1mU6tWrbRkyRIdOnSoSn9Wcps6daqysrLUrVs3DR8+XCEhIZo7d65OnTql6dOn+7Q+AAAAAJxRXAYAAJD09NNPa/HixVq6dKnmzZun4uJiJSYmavjw4XrkkUcUExPj1P6qq65SamqqJk+erH379uniiy/W/Pnz1b59e0txQ0ND9eqrr2rixIm69957VVpaqldeeeWMxeX27dvrww8/1Lhx45SRkaFzzz1XkydP1oEDBzwWl0ePHq333ntPH330kU6dOqUWLVpo6tSpmjBhgqNN//79NWrUKC1cuFCvvfaajDE+F5eDg4O1fPly3XfffZowYYIaNGigSZMmKSMjw6nd7NmzVVJSohdffFF2u1233HKLZsyYobZt2zq1s5JbmzZt9Nlnn2nixImaNm2aysvLlZKSotdee00pKSk+rQ8AAAAAZzbDr5QAAABYYrPZNGLECKdHPgAAAADAnw3PXAYAAAAAAAAAWEZxGQAAAAAAAABgGcVlAAAAAAAAAIBl/KAfAACARfxkBQAAAABw5zIAAAAAAAAAwAcUlwEAAAAAAAAAlgX8sRjl5eXav3+/GjRoIJvNFujwAAAAAAAAQK1mjNHRo0fVtGlTBQVx7yhqTsCLy/v371fz5s0DHRYAAAAAAACoU/Lz83XuuefWdBr4Ewt4cblBgwb/+ytfUpRXy3TIvlKbr1pVbTl5itsh+0rHNFd5nCk/K3l7imE1jj+2maucKk9zNd3K+lZs20B8tp7inJ5/5fen7wee+vFmfuV27mJ7ytdTO0/LV1729Jys7FOnz3O3Dqfn7m6cnc02d7eNrOyv7j4rT9Ncxbc6VjzlVtGXN9vcyuftax7u2ng6fvnj8/a0Ht4sb/XYfab9y1M+3hxb/LG/uBqfvvbny7bxdDw523wk746XruJ52i+tnpvdHQurYz09HZfd5V25TeV2vlxTeHN+8PW86il3K3md6RxsNb4310LuzgO+xPF2Pa2cq630Z2Vfs3Je9nSurulrxOq6nnbXzkq8QH5H8nbcerrmcNWnp5i+5lMdn6231y2nHwMq2lm5ZvYmtqtlvf2edbbz3S3jz+vMs+HrvufPWNUV25/fKazG9fV62137yqyOW0/HWW/3A6vXuafH88d3Kk/H1gq/tyuU1LxSnQ2oGQEvLv/+KIwoeVtcDo4M9rqtP1XE/e3fClXzOFN+VvL2FMNqHH9sM1c5OU9zNd3aZxqoz9ZTnNPzr/y+6n7gqR/P8yu3cxfbc77u23lePuq0aVFV/nY133V/p/flOrfTc3c3zs5mm7vbRlb2V3efledpVeNbHSuec/utL++2ufeft695uG/j/vjln8/b/Xp4s7z1Y/eZ9i/3+XhzbPHH/uJ6fPrWny/bxtPx5OzzkdvlXR9j3cf29vzvqT9f9ytP6+AqtrfLuG7zeztfrim8OT/4el71nLv3eZ35HGwtvjfXQu7OA77F8W49rZyrrfRnZV+zcl72fK6u2WvE6rqedt/O+3iB/I7k7bj1dM3hqk9PMX3Npzo+W2+vW6oeA35rZ+Wa2bvYVZf19nvW2c53t4w/rzPPhq/7nj9jVVdsf36nsB7Xt+tt9+0r86UecuZlvd0PrF/nOsfzz3cqT8fWCs7teOQsalpQTScAAAAAAAAAAKh9KC4DAAAAAAAAACyjuAwAAAAAAAAAsCzgz1wGAAAAAAAAgOpQVlamkpKSmk6j1goODlZISIjXz/OmuAwAAAAAAACg1isqKtL3338vY0xNp1KrRUREqEmTJgoLC/PYluIyAAAAAAAAgFqtrKxM33//vSIiIhQXF+f1nbf4nTFGxcXFOnz4sHJzc5WcnKygIPdPVaa4DAAAAAAAAKBWKykpkTFGcXFxqlevXk2nU2vVq1dPoaGh2rt3r4qLixUeHu62PT/oBwAAAAAAAKBO4I7ls+fpbmWnttWYBwAAAAAAAACgjqK4DAAAAAAAAACwjOIyAAAAAAAAANQRSUlJevbZZwMSi+IyAAAAAAAAgDrJZgvsy1puNrevzMxMn9Z57dq1GjZsmE/LWmW5uLxq1Spdd911atq0qWw2m955551qSAsAAAAAAAAA6q4DBw44Xs8++6yioqKcpo0fP97R1hij0tJSr/qNi4tTREREdaXtxHJx+dixY+rQoYPmzJlTHfkAAAAAAAAAQJ2XkJDgeEVHR8tmsznef/vtt2rQoIGWLVumTp06yW63a/Xq1dq9e7euv/56xcfHKzIyUl26dNHHH3/s1O/pj8Ww2Wx6+eWX1a9fP0VERCg5OVnvvfeeX9bBcnG5b9++mjp1qvr16+eXBAAAAAAAAAAAVT300EN68skntX37drVv315FRUW65pprtGLFCm3cuFHp6em67rrrtG/fPrf9TJ48Wbfccou2bNmia665RoMGDdIvv/xy1vlV+zOXT506pcLCQqcXAAAAAAAAAMC9KVOmqHfv3mrVqpViY2PVoUMH3XPPPWrbtq2Sk5P12GOPqVWrVh7vRB4yZIgGDhyo888/X0888YSKioq0Zs2as86v2ovL06ZNU3R0tOPVvHnz6g4JAAAAAAAAALVe586dnd4XFRVp/PjxuuiiixQTE6PIyEht377d453L7du3d/xdv359RUVF6dChQ2edX7UXlydOnKhff/3V8crPz6/ukAAAAAAAAABQ69WvX9/p/fjx4/X222/riSee0GeffaZNmzapXbt2Ki4udttPaGio03ubzaby8vKzzi/krHvwwG63y263V3cYAAAAAAAAAKjTPv/8cw0ZMsTxe3hFRUXKy8ursXyq/c5lAAAAAAAAAMDZS05O1ltvvaVNmzZp8+bNuu222/xyB7KvLN+5XFRUpO+++87xPjc3V5s2bVJsbKwSExP9mhwAAAAAAAAA+MqYms7Av2bOnKm77rpLl19+uRo1aqQHH3xQhYWFNZaP5eLyunXrdPXVVzvejxs3TpI0ePBgzZ8/32+JAQAAAAAAAMCfwZAhQzRkyBDH+x49esi4qIwnJSVp5cqVTtNGjBjh9P70x2S46qegoMDnXCuzXFw+04oBAAAAAAAAAP48eOYyAAAAAAAAAMAyissAAAAAAAAAAMsoLgMAAAAAAAAALKO4DAAAAAAAAACwjOIyAAAAAAAAAMAyissAAAAAAAAAAMsoLgMAAAAAAAAALKO4DAAAAAAAAACwjOIyAAAAAAAAAMCykJpOAAAAAAAAAACqQ6cNnQIab/2l671ua7PZ3M6fNGmSMjMzfcrDZrPp7bff1g033ODT8t6iuAwAAAAAAAAAAXbgwAHH34sWLVJGRoZ27NjhmBYZGVkTaVkS8OKyMeZ/fxV6vUxZUZml9v5SEfe3fytUzeNM+VnJ21MMq3H8sc1c5eQ8zdV0K+tbGLDP1lOc0/Ov/L7qfuCpH8/zK7dzF9tzvu7beV6+8LRphVX+djXfdX+n9+U6t9NzdzfOzmabu9tGVvZXd5+V52lV41sdK55z+60v77a595+3r3m4b+P++OWfz9v9enizvPVj95n2L/f5eHNs8cf+4np8+tafL9vG0/Hk7POR2+VdH2Pdx/b2/O+pP1/3K0/r4Cq2t8u4bvN7O1+uKbw5P/h6XvWcu/d5nfkcbC2+N9dC7s4DvsXxbj2tnKut9GdlX7NyXvZ8rq7Za8Tqup523+6P+R3J23Hr6ZrDVZ+eYvqaT3V8tt5et1Q9BvzWzso1s3exqy7r7fess53vbhl/XmeeDV/3PX/Gqq7Y/vxOYT2ub9fb7ttX5ks95MzLersfWL/OdY7nn+9Uno6tFQqd/v29zobaKCEhwfF3dHS0bDab07SXX35ZzzzzjHJzc5WUlKTRo0dr+PDhkqTi4mKNGzdO//3vf3XkyBHFx8fr3nvv1cSJE5WUlCRJ6tevnySpRYsWysvLq5Z1sJkA74V79uxRq1atAhkSAAAAAAAAqHN2796t8847r6bT+EM4efKkcnNz1bJlS4WHhzum/5Efi1HZ/PnzNXbsWBUUFEiSFixYoAkTJui5555Tx44dtXHjRg0dOlQzZ87U4MGD9fTTT2vWrFlasGCBEhMTlZ+fr/z8fA0cOFCHDx9W48aN9corryg9PV3BwcGKi4vzOpczbUtXAn7ncmxsrCRp3759io6ODnR4ANWosLBQzZs3V35+vqKiomo6HQB+xPgG6i7GN1B3Mb6BuuvXX39VYmKio86GumfSpEl65pln1L9/f0lSy5YttW3bNs2dO1eDBw/Wvn37lJycrG7duslms6lFixaOZSsKyTExMU53QleHgBeXg4KCJP12qzcnN6BuioqKYnwDdRTjG6i7GN9A3cX4Buquijob6pZjx45p9+7duvvuuzV06FDH9NLSUsfNukOGDFHv3r3VunVrpaen6y9/+Yv69OkT8Fz5QT8AAAAAAAAA+IMoKiqSJL300ktKSUlxmhccHCxJuvTSS5Wbm6tly5bp448/1i233KJevXrpzTffDGiuFJcBAAAAAAAA4A8iPj5eTZs21Z49ezRo0KAztouKitKtt96qW2+9VTfddJPS09P1yy+/KDY2VqGhoSorc/Ujs/4V8OKy3W7XpEmTZLfbAx0aQDVjfAN1F+MbqLsY30DdxfgG6i7Gd903efJkjR49WtHR0UpPT9epU6e0bt06HTlyROPGjdPMmTPVpEkTdezYUUFBQVq8eLESEhIUExMjSUpKStKKFSt0xRVXyG63q2HDhtWSp80YY6qlZwAAAAAAAAAIgJMnTyo3N1ctW7ZUeHh4Tadj2fz58zV27FgVFBQ4pr3++uuaMWOGtm3bpvr166tdu3YaO3as+vXrp5deeknPP/+8du3apeDgYHXp0kUzZsxQx44dJUnvv/++xo0bp7y8PDVr1kx5eXle52JlW1JcBgAAAAAAAFCr1fbi8h+JlW3JT0oCAAAAAAAAACyjuAwAAAAAAAAAsIziMgAAAAAAAADAMorLAAAAAAAAAADLAlpcnjNnjpKSkhQeHq6UlBStWbMmkOEBWDRt2jR16dJFDRo0UOPGjXXDDTdox44dTm1OnjypESNG6JxzzlFkZKRuvPFG/fjjj05t9u3bp2uvvVYRERFq3LixJkyYoNLS0kCuCgAPnnzySdlsNo0dO9YxjfEN1F4//PCDbr/9dp1zzjmqV6+e2rVrp3Xr1jnmG2OUkZGhJk2aqF69eurVq5d27drl1Mcvv/yiQYMGKSoqSjExMbr77rtVVFQU6FUBUElZWZkeffRRtWzZUvXq1VOrVq302GOPyRjjaMP4BmqPVatW6brrrlPTpk1ls9n0zjvvOM3313jesmWLunfvrvDwcDVv3lzTp0+v7lWrUZWPifCNlW0YsOLyokWLNG7cOE2aNEkbNmxQhw4dlJaWpkOHDgUqBQAWZWdna8SIEfryyy+VlZWlkpIS9enTR8eOHXO0uf/++/X+++9r8eLFys7O1v79+9W/f3/H/LKyMl177bUqLi7WF198oVdffVXz589XRkZGTawSABfWrl2ruXPnqn379k7TGd9A7XTkyBFdccUVCg0N1bJly7Rt2zY988wzatiwoaPN9OnTNWvWLL344ov66quvVL9+faWlpenkyZOONoMGDdI333yjrKwsLVmyRKtWrdKwYcNqYpUA/M9TTz2lF154Qc8995y2b9+up556StOnT9fs2bMdbRjfQO1x7NgxdejQQXPmzHE53x/jubCwUH369FGLFi20fv16zZgxQ5mZmZo3b161r1+gBQcHS5KKi4trOJPa7/jx45Kk0NBQz41NgHTt2tWMGDHC8b6srMw0bdrUTJs2LVApADhLhw4dMpJMdna2McaYgoICExoaahYvXuxos337diPJ5OTkGGOMWbp0qQkKCjIHDx50tHnhhRdMVFSUOXXqVGBXAEAVR48eNcnJySYrK8tcddVVZsyYMcYYxjdQmz344IOmW7duZ5xfXl5uEhISzIwZMxzTCgoKjN1uN2+88YYxxpht27YZSWbt2rWONsuWLTM2m8388MMP1Zc8ALeuvfZac9dddzlN69+/vxk0aJAxhvEN1GaSzNtvv+1476/x/Pzzz5uGDRs6XZ8/+OCDpnXr1tW8RoFXXl5u8vLyzK5du8yxY8fMiRMneFl8HT9+3Pz0009m27ZtZv/+/V5t95DqqnBXVlxcrPXr12vixImOaUFBQerVq5dycnICkQIAP/j1118lSbGxsZKk9evXq6SkRL169XK0ufDCC5WYmKicnBxddtllysnJUbt27RQfH+9ok5aWpvvuu0/ffPONOnbsGNiVAOBkxIgRuvbaa9WrVy9NnTrVMZ3xDdRe7733ntLS0nTzzTcrOztbzZo10/DhwzV06FBJUm5urg4ePOg0vqOjo5WSkqKcnBwNGDBAOTk5iomJUefOnR1tevXqpaCgIH311Vfq169fwNcLgHT55Zdr3rx52rlzpy644AJt3rxZq1ev1syZMyUxvoG6xF/jOScnR1deeaXCwsIcbdLS0vTUU0/pyJEjTv+zqbaz2Wxq0qSJcnNztXfv3ppOp1aLiYlRQkKCV20DUlz+6aefVFZW5vTlU5Li4+P17bffBiIFAGepvLxcY8eO1RVXXKG2bdtKkg4ePKiwsDDFxMQ4tY2Pj9fBgwcdbVyN/Yp5AGrOwoULtWHDBq1du7bKPMY3UHvt2bNHL7zwgsaNG6eHH35Ya9eu1ejRoxUWFqbBgwc7xqer8Vt5fDdu3NhpfkhIiGJjYxnfQA166KGHVFhYqAsvvFDBwcEqKyvT448/rkGDBkkS4xuoQ/w1ng8ePKiWLVtW6aNiXl0qLktSWFiYkpOTeTTGWQgNDXU8YsQbASkuA6j9RowYoa1bt2r16tU1nQoAP8jPz9eYMWOUlZWl8PDwmk4HgB+Vl5erc+fOeuKJJyRJHTt21NatW/Xiiy9q8ODBNZwdgLPxn//8RwsWLNDrr7+uNm3aaNOmTRo7dqyaNm3K+AaA/wkKCuI7TgAF5Af9GjVqpODg4Cq/MP/jjz96fYs1gJozcuRILVmyRJ988onOPfdcx/SEhAQVFxeroKDAqX3lsZ2QkOBy7FfMA1Az1q9fr0OHDunSSy9VSEiIQkJClJ2drVmzZikkJETx8fGMb6CWatKkiS6++GKnaRdddJH27dsn6ffx6e7aPCEhocoPb5eWluqXX35hfAM1aMKECXrooYc0YMAAtWvXTnfccYfuv/9+TZs2TRLjG6hL/DWeuWZHdQtIcTksLEydOnXSihUrHNPKy8u1YsUKpaamBiIFAD4wxmjkyJF6++23tXLlyir/laZTp04KDQ11Gts7duzQvn37HGM7NTVVX3/9tdMJLysrS1FRUVW++AIInJ49e+rrr7/Wpk2bHK/OnTtr0KBBjr8Z30DtdMUVV2jHjh1O03bu3KkWLVpIklq2bKmEhASn8V1YWKivvvrKaXwXFBRo/fr1jjYrV65UeXm5UlJSArAWAFw5fvy4goKcv8YHBwervLxcEuMbqEv8NZ5TU1O1atUqlZSUONpkZWWpdevWde6RGKgh1fs7jb9buHChsdvtZv78+Wbbtm1m2LBhJiYmxukX5gH8sdx3330mOjrafPrpp+bAgQOO1/Hjxx1t7r33XpOYmGhWrlxp1q1bZ1JTU01qaqpjfmlpqWnbtq3p06eP2bRpk1m+fLmJi4szEydOrIlVAuDGVVddZcaMGeN4z/gGaqc1a9aYkJAQ8/jjj5tdu3aZBQsWmIiICPPaa6852jz55JMmJibGvPvuu2bLli3m+uuvNy1btjQnTpxwtElPTzcdO3Y0X331lVm9erVJTk42AwcOrIlVAvA/gwcPNs2aNTNLliwxubm55q233jKNGjUyDzzwgKMN4xuoPY4ePWo2btxoNm7caCSZmTNnmo0bN5q9e/caY/wzngsKCkx8fLy54447zNatW83ChQtNRESEmTt3bsDXF3VTwIrLxhgze/Zsk5iYaMLCwkzXrl3Nl19+GcjwACyS5PL1yiuvONqcOHHCDB8+3DRs2NBERESYfv36mQMHDjj1k5eXZ/r27Wvq1atnGjVqZP7xj3+YkpKSAK8NAE9OLy4zvoHa6/333zdt27Y1drvdXHjhhWbevHlO88vLy82jjz5q4uPjjd1uNz179jQ7duxwavPzzz+bgQMHmsjISBMVFWXuvPNOc/To0UCuBoDTFBYWmjFjxpjExEQTHh5uzjvvPPN///d/5tSpU442jG+g9vjkk09cfucePHiwMcZ/43nz5s2mW7duxm63m2bNmpknn3wyUKuIPwGbMcbUzD3TAAAAAAAAAIDaKiDPXAYAAAAAAAAA1C0UlwEAAAAAAAAAllFcBgAAAAAAAABYRnEZAAAAAAAAAGAZxWUAAAAAAAAAgGUUlwEAAAAAAAAAllFcBgAAAAAAAABYRnEZAAAAAAAAAGAZxWUAAAAAAAAAgGUUlwEAAAAAAAAAllFcBgAAAAAAAABY9v96EVJPyJWhhwAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 1600x50 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABZkAAAB0CAYAAADn0TykAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAoD0lEQVR4nO3de3gUVZ7G8bfThARy5R6ihDAIiFzlIhMBBx+QBB1WEUdZmR1gGJmVRIbJiso8GgIiGUAdhoAo+iywK47IjDCscouMXEW5CAwCBsXEZIZL2BUMl4RcuvYPTdvdqeruNEnHxO/neep50lWnzvmdU+dUVR+KapthGIYAAAAAAAAAAAhASH0HAAAAAAAAAABouJhkBgAAAAAAAAAEjElmAAAAAAAAAEDAmGQGAAAAAAAAAASMSWYAAAAAAAAAQMCYZAYAAAAAAAAABIxJZgAAAAAAAABAwJhkBgAAAAAAAAAEjElmAAAAAAAAAEDAmGQGAACoIytXrpTNZlN+fr5z3bBhwzRs2LBaLyszM1M2m81tXWJioiZOnFjrZXnKz8+XzWbTypUrnesmTpyoyMjIOi+7is1mU2ZmZtDKAwAAAPAdJpkBAAC+dfToUT3wwAPq2LGjwsPDdcMNN+iuu+5SdnZ2nZV5+vRpZWZm6vDhw3VWRk1s3LjxeztZ+32ODQAAAPgha1LfAQAAAHwffPDBB7rzzjuVkJCgRx55RHFxcSosLNSHH36oP/7xj3rsscdqpZytW7e6fT59+rRmz56txMRE9e3bt1bKqJKbm6uQkJo9U7Bx40YtXbq0RpO5HTt2VElJiUJDQ2sYYc14i62kpERNmnBrCwAAANQH7sQBAAAkPffcc4qJidH+/fsVGxvrtq2oqKjWymnatGmt5eVLWFhYneZfUVEhh8Ohpk2bKjw8vE7L8qW+ywcAAAB+yHhdBgAAgKRTp06pR48e1SaYJalt27Zun202m9LS0rR69Wp169ZN4eHh6t+/v3bu3OmzHNd3Mm/fvl0DBw6UJE2aNEk2m63au43N7N69WwMHDlR4eLg6d+6sV155xTSd5zuZy8vLNXv2bHXp0kXh4eFq1aqVhgwZopycHEnfvEd56dKlzjpWLdJ3711+/vnntWjRInXu3FlhYWE6fvy46TuZq3zxxRdKTk5WRESE4uPjNWfOHBmG4dy+fft22Ww2bd++3W0/zzy9xVa1zvMJ50OHDmnUqFGKjo5WZGSkhg8frg8//NAtTdV7s/fs2aP09HS1adNGERERGjNmjM6fP29+AAAAAAC44UlmAAAAffPKh7179+qTTz5Rz549fabfsWOH1qxZo2nTpiksLEwvvfSSUlJStG/fPr/2l6Tu3btrzpw5ysjI0JQpUzR06FBJ0u233265z9GjRzVy5Ei1adNGmZmZqqio0KxZs9SuXTuf5WVmZiorK0u/+tWvdNttt6m4uFgHDhzQxx9/rLvuuku//vWvdfr0aeXk5Oi///u/TfNYsWKFSktLNWXKFIWFhally5ZyOBymaSsrK5WSkqIf//jHWrBggTZv3qxZs2apoqJCc+bM8aOFvuNPbK6OHTumoUOHKjo6Wk888YRCQ0P1yiuvaNiwYdqxY4cGDRrklv6xxx5TixYtNGvWLOXn52vRokVKS0vTmjVrahQnAAAA8EPEJDMAAICkxx9/XKNGjVLfvn112223aejQoRo+fLjuvPNO03cNf/LJJzpw4ID69+8vSRo3bpy6deumjIwMvf32236V2a5dO40aNUoZGRlKSkrSz3/+c5/7ZGRkyDAM7dq1SwkJCZKksWPHqlevXj73fffdd3X33Xdr+fLlptuTkpLUtWtX5eTkWMbyj3/8Q59//rnatGnjXJefn2+atrS0VCkpKVq8eLEkaerUqRo9erTmz5+vadOmqXXr1j5jrklsrp5++mmVl5dr9+7d+tGPfiRJ+sUvfqFu3brpiSee0I4dO9zSt2rVSlu3bnU+He1wOLR48WJ9/fXXiomJ8TtOAAAA4IeI12UAAABIuuuuu7R37179y7/8i44cOaIFCxYoOTlZN9xwgzZs2FAtfVJSknOCWZISEhJ07733asuWLaqsrKyTGCsrK7Vlyxbdd999zglm6ZsnopOTk33uHxsbq2PHjumzzz4LOIaxY8e6TTD7kpaW5vy76jUjZWVleu+99wKOwZfKykpt3bpV9913n3OCWZLat2+vhx9+WLt371ZxcbHbPlOmTHF7/cbQoUNVWVmpL7/8ss7iBAAAABoLJpkBAAC+NXDgQL399tu6cOGC9u3bp5kzZ+rSpUt64IEHdPz4cbe0Xbp0qbZ/165ddfXq1Tp7l+/58+dVUlJiWna3bt187j9nzhxdvHhRXbt2Va9evTRjxgz9/e9/r1EMnTp18jttSEiI2ySv9E0bSdZPP9eG8+fP6+rVq6Zt0r17dzkcDhUWFrqtd520l6QWLVpIki5cuFBncQIAAACNBZPMAAAAHpo2baqBAwdq3rx5WrZsmcrLy7V27dr6Duu63XHHHTp16pT+8z//Uz179tRrr72mfv366bXXXvM7j2bNmtVqTK5PD7uqq6fBrdjtdtP1rj9SCAAAAMAck8wAAABeDBgwQJJ05swZt/Vmr5w4efKkmjdvXqPXSVhNsppp06aNmjVrZlp2bm6uX3m0bNlSkyZN0p/+9CcVFhaqd+/eyszMDCgeXxwOh7744gu3dSdPnpQkJSYmSvruieGLFy+6pTN7TYW/sbVp00bNmzc3bZNPP/1UISEh6tChg195AQAAAPCNSWYAAABJ77//vulTqxs3bpRU/XUUe/fu1ccff+z8XFhYqL/+9a8aOXKk5VOxZiIiIiRVn2Q1Y7fblZycrPXr16ugoMC5/sSJE9qyZYvP/f/v//7P7XNkZKRuuukmXbt2LaB4/LFkyRLn34ZhaMmSJQoNDdXw4cMlSR07dpTdbtfOnTvd9nvppZeq5eVvbHa7XSNHjtRf//pXt9dynDt3Tm+88YaGDBmi6OjoAGsEAAAAwFOT+g4AAADg++Cxxx7T1atXNWbMGN18880qKyvTBx98oDVr1igxMVGTJk1yS9+zZ08lJydr2rRpCgsLc06Kzp49u0bldu7cWbGxsXr55ZcVFRWliIgIDRo0yPLdx7Nnz9bmzZs1dOhQTZ06VRUVFcrOzlaPHj18vl/5lltu0bBhw9S/f3+1bNlSBw4c0J///Ge3H+er+jHDadOmKTk5WXa7XePGjatRnaqEh4dr8+bNmjBhggYNGqRNmzbp3Xff1e9+9zvn094xMTH62c9+puzsbNlsNnXu3FnvvPOOioqKquVXk9jmzp2rnJwcDRkyRFOnTlWTJk30yiuv6Nq1a1qwYEFA9QEAAABgjklmAAAASc8//7zWrl2rjRs3avny5SorK1NCQoKmTp2qp59+WrGxsW7pf/KTnygpKUmzZ89WQUGBbrnlFq1cuVK9e/euUbmhoaFatWqVZs6cqX//939XRUWFVqxYYTnJ3Lt3b23ZskXp6enKyMjQjTfeqNmzZ+vMmTM+J5mnTZumDRs2aOvWrbp27Zo6duyouXPnasaMGc40999/vx577DG9+eabev3112UYRsCTzHa7XZs3b9ajjz6qGTNmKCoqSrNmzVJGRoZbuuzsbJWXl+vll19WWFiYHnzwQS1cuFA9e/Z0S1eT2Hr06KFdu3Zp5syZysrKksPh0KBBg/T6669r0KBBAdUHAAAAgDmbwa+ZAAAA1IjNZlNqaqrbqyAAAAAA4IeKdzIDAAAAAAAAAALGJDMAAAAAAAAAIGBMMgMAAAAAAAAAAsYP/wEAANQQP2kBAAAAAN/hSWYAAAAAAAAAQMCYZAYAAAAAAAAABCzor8twOBw6ffq0oqKiZLPZgl08AAAAAAAA0KAZhqFLly4pPj5eISE8Q4r6F/RJ5tOnT6tDhw7BLhYAAAAAAABoVAoLC3XjjTfWdxhA8F+XERUVJUnatWuXpIvqs6OP+uzoo0OHDkm66LYcOnTIbXHd1mdHn2ppqtZ7pq9K6y3/qs9m+5jFYJana9lm8Vmtc93mmlfVOte/XfcxazPXmM3a13Mfq3Y3y9NbPFbprepldfzM2tezXKvyfLWFZzlWf1vFbnWsveXpLV+r7d76jLd+4brdVzmBtptnm3iOCX/azDU+q/ayit1szHo7jlZ9yupY+Wonzzp6nie8tYW3uL31Gc9tZucm1z5hdRy9tZHZ8fDsi1blWOVn1RZm/dTqGuCtDXz1NauyXde79jNfdfDVh2oyjvzpX2Z9zao+Vn3c81j606et+rG3/mdWttU48be/Wx0vs35p1Sd9xeRPe5mdi/25DvnbN7zF6BmPr7Folrdnnb21eU3bx9f51jVGX+chb/3OtTxvcfk7Hvw9Pt4Wf6+x/owDz/Fg1S9qGrM/5Vm1Z03Pbb7ayFt8gVxXfZXtq+2s7l19Ha+aHANvMQZ6fK1iMuuDntdas33MziPezvFW9y2++rNnPa1i9nUvY9ZnrfqxWX/xPC/56qc1HXOe1w2re1yr/ueZzqzdXGP2zNNbO1m1q9Wx9fd64O185e34mo1lb9c2z+uJP9cgf46Zt77mrY2szk2edXQ9Ft7uJ8zGndU5xNt1wlc/9jWOPe+1atr/zca32ViwOjd51sfq3OR5X+hPbL6OvVme/sYZSPlm5wur4+DZl6qXWSDpu3k2oL4F/UnmqldkREZGSrZo2SPtkr4dFLZot7TVBorLdnukXbJFu6f5Nj/num/TV6X15Lmvawyu+3ims8rTtWy7o3p8VuuioqKc29zq51In1xir9vFsk2p1M2lfz3a2bHeTfKvqbBaPZXqPGJ3rXPZ3/exZlmm5Xuptxq3uLvu61tOzzmaxe9bNLPZqeZrV69t1Vtu99Rm7w7pfuG13ictXX7Fi1m6e/b7amPFSTlXdXGO0aq9q49tiLHo7pmblW8Vu1Q9N83BJU+084aUtXGO1OibejpXnucVsndl5yZ8xb3YertbHLcqxzM+iLTz7gLe4vLaBS56ezM5VrmWYnod81cFH//cas5/j0Oq877bNpD5mMXvm6/W8bpGn5TnGy5g1i8XnNdjP61i1/apY9EmfMVmU7dpeZtd0X/3PNQZvLK/9Xu4tnOu8jHm3vF3iNLs/8iynRu1jsd1zf7P+5+2zt3seb23v73gwS1tTvq7lZjF4i8cZU9V+Jv2ipjH7U55Ve9b43ObnPaBZfIFcV32V7VmOWX8zu3f1dbxqcgy8xWh2bvK3Lpb3DZJ5HS22SebnEdPvPxbj2LWepvX3KNvsXGY2Zr3V07PPWvVjs/5S7Rpr0v/8qZuVatd7jzhd47H67uTzu4HN47udRx29nStrco/g7/XA6jpm+R3IZvL9xeRaa3X9tvr+ZVYnf46d1zHlZYxanZs86+jaP73eT7iUZ/pdx8v49VVn03t7i3Hser8VUP/3ZHKN9HZucuXt2uB5X+jv9apa/mbnDJc8/Zl78KeveWtzy3tal3Ru80Vm8RjfruJVtPie4KUtAAAAAAAAAICAMckMAAAAAAAAAAgYk8wAAAAAAAAAgIAF/Z3MAAAAAAAAAFAXHA6HysrK6juMRiE0NFR2e/XfVTLDJDMAAAAAAACABq+srEx5eXlyOBz1HUqjERsbq7i4OJ8/MskkMwAAAAAAAIAGzTAMnTlzRna7XR06dFBICG8Jvh6GYejq1asqKiqSJLVv395reiaZAQAAAAAAADRoFRUVunr1quLj49W8efP6DqdRaNasmSSpqKhIbdu29frqDKb0AQAAAAAAADRolZWVkqSmTZvWcySNS9WEfXl5udd0TDIDAAAAAAAAaBR8vTsYNeNvezLJDAAAAAAAAAAIGJPMAAAAAAAAAICA8cN/AAAAAAAAABqlU6dOBbW8zp071yj9xIkTtWrVKmVlZempp55yrl+/fr3GjBkjwzBqO8Q6UeMnmXfu3KnRo0crPj5eNptN69evr4OwAAAAAAAAAKDxCw8P1/z583XhwoX6DiVgNZ5kvnLlivr06aOlS5fWRTwAAAAAAAAA8IMxYsQIxcXFKSsryzLNX/7yF/Xo0UNhYWFKTEzUCy+84LY9MTFR8+bN0y9/+UtFRUUpISFBy5cvd0tTWFioBx98ULGxsWrZsqXuvfde5efn10odajzJPGrUKM2dO1djxoyplQAAAAAAAAAA4IfKbrdr3rx5ys7O1j/+8Y9q2w8ePKgHH3xQ48aN09GjR5WZmalnnnlGK1eudEv3wgsvaMCAATp06JCmTp2qRx99VLm5uZKk8vJyJScnKyoqSrt27dKePXsUGRmplJQUlZWVXXcd6vyH/65du6bi4mK3BQAAAAAAAADwjTFjxqhv376aNWtWtW0vvviihg8frmeeeUZdu3bVxIkTlZaWpoULF7qlu/vuuzV16lTddNNNevLJJ9W6dWu9//77kqQ1a9bI4XDotddeU69evdS9e3etWLFCBQUF2r59+3XHX+eTzFlZWYqJiXEuHTp0qOsiAQAAAAAAAKBBmT9/vlatWqUTJ064rT9x4oQGDx7stm7w4MH67LPPVFlZ6VzXu3dv5982m01xcXEqKiqSJB05ckSff/65oqKiFBkZqcjISLVs2VKlpaW18uOITa47Bx9mzpyp9PR05+fi4mImmgEAAAAAAADAxR133KHk5GTNnDlTEydOrPH+oaGhbp9tNpscDock6fLly+rfv79Wr15dbb82bdoEFK+rOp9kDgsLU1hYWF0XAwAAAAAAAAAN2u9//3v17dtX3bp1c67r3r279uzZ45Zuz5496tq1q+x2u1/59uvXT2vWrFHbtm0VHR1dqzFLQXhdBgAAAAAAAADAt169emn8+PFavHixc91//Md/aNu2bXr22Wd18uRJrVq1SkuWLNHjjz/ud77jx49X69atde+992rXrl3Ky8vT9u3bNW3aNNMfG6ypGk8yX758WYcPH9bhw4clSXl5eTp8+LAKCgquOxgAAAAAAAAA+CGbM2eO8zUX0jdPIb/11lt688031bNnT2VkZGjOnDk1eqVG8+bNtXPnTiUkJOj+++9X9+7dNXnyZJWWltbKk801fl3GgQMHdOeddzo/V71vecKECVq5cuV1BwQAAAAAAAAAtaFz5871HYJXZvOpiYmJunbtmtu6sWPHauzYsZb55OfnV1tX9ZBwlbi4OK1atSqQMH2q8STzsGHDZBhGXcQCAAAAAAAAAGhgeCczAAAAAAAAACBgTDIDAAAAAAAAAALGJDMAAAAAAAAAIGBMMgMAAAAAAAAAAsYkMwAAAAAAAAAgYEwyAwAAAAAAAAACxiQzAAAAAAAAACBgTDIDAAAAAAAAAALGJDMAAAAAAAAANBKJiYlatGhRUMtkkhkAAAAAAABAo2SzBXepWWw2r0tmZmZAdd6/f7+mTJkS0L6BahLU0gAAAAAAAAAAOnPmjPPvNWvWKCMjQ7m5uc51kZGRzr8Nw1BlZaWaNPE9ndumTZvaDdQPPMkMAAAAAAAAAEEWFxfnXGJiYmSz2ZyfP/30U0VFRWnTpk3q37+/wsLCtHv3bp06dUr33nuv2rVrp8jISA0cOFDvvfeeW76er8uw2Wx67bXXNGbMGDVv3lxdunTRhg0barUuQX+S2TAMSdLly5clo1iVlyslSZdCLklGsVvaS5cueez83fbKy5WSUeye5tv8LoVccktfldaT576XLl0y3ccznVWermWbxWe17lLIpWr5VbWLaxtV7WtWR9O6mbSvax1d05nt66kqRrN4LNN7xOhc57K/62fPskzL9VJvM1X1cZblelxN/raK3bNuzmPgLU+zen27zmq7a76efcZbv3Db7hKXWTn+MGs3z2Ndbcx4Kcetr1ftH2LeXtXGisVY9HZMzcq3it2qH5rm4ZKm2nnCS1u4xmp1TLwdK7dj7BG32xjxMZ7N2sjsPFytj1uUY5mfRVs4zxme9TO5BnhtA5c8PZmdq1xjNT0P+aqDj/7vNWY/x6HV+HbbZlIfs5g987VqX6s28tzmrf+ZtY1Z+3ny1Samx0uq1i+t+qTPmCzKdm0vz3q79V8vx9LfvuEtxmrxeKyzGvNuebvE6eveocbtY7Hdc3+z/uftvOTtnsdbXP6OB7O0NeXrWm4Wg7d4nDGZ7Ff12Z9zpFXZVuVZtWeNz21+3gOaxRfIddVX2Z7lmPU/q7Hm7XjVpN94izHQ42sZUxWzOlpsc83Pqt6e53jL72rezu8uZZudy8zGrLd6er2n8Mzr23XVriUuZdTknOJLteu9R5yu8dTkuuh5znW7Z/Ooo7f7pJrcI/h7PbC6jpldI6y+R5pda62ujVbfv8zq5M+x8zqmvIxRq3OTZx1dv/eYzRFY3tu5rDO9XprE7rVPeY5Bi3Fs9R3NH9XmbVzj96if1bnJlbdrg9n3XZ+x+XEe9szT7zgDKN/0fGFSblUf8vwO7Z7fN39XzbOh8Xrqqaf0/PPP60c/+pFatGihwsJC3X333XruuecUFham//qv/9Lo0aOVm5urhIQEy3xmz56tBQsWaOHChcrOztb48eP15ZdfqmXLlrUTqBFkp06dMiSxsLCwsLCwsLCwsLCwsLCwsLCwXMdy6tSpYE/tfW+VlJQYx48fN0pKStzWS8FdArVixQojJibG+fn99983JBnr16/3uW+PHj2M7Oxs5+eOHTsaf/jDH1zaQMbTTz/t/Hz58mVDkrFp0yafeVu1q6egP8lcNTteUFCgmJiYYBcPoA4VFxerQ4cOKiwsVHR0dH2HA6AWMb6BxovxDTRejG+g8fr666+VkJBQe0+h4ntrwIABbp8vX76szMxMvfvuuzpz5owqKipUUlKigoICr/n07t3b+XdERISio6NVVFRUa3EGfZI5JCREkhQTE8NFDmikoqOjGd9AI8X4BhovxjfQeDG+gcarap4NjVdERITb58cff1w5OTl6/vnnddNNN6lZs2Z64IEHVFZW5jWf0NBQt882m00Oh6PW4gz6JDMAAAAAAAAAoOb27NmjiRMnasyYMZK+ebI5Pz+/foOSxD93AAAAAAAAAEAD0KVLF7399ts6fPiwjhw5oocffrhWn0gOVNAnmcPCwjRr1iyFhYUFu2gAdYzxDTRejG+g8WJ8A40X4xtovBjf/gv2T//VtRdffFEtWrTQ7bffrtGjRys5OVn9+vWr+4J9sH37C4MAAAAAAAAA0CCVlpYqLy9PnTp1Unh4eH2H02j42668LgMAAAAAAAAAEDAmmQEAAAAAAAAAAWOSGQAAAAAAAAAQMCaZAQAAAAAAAAABC+ok89KlS5WYmKjw8HANGjRI+/btC2bxAGooKytLAwcOVFRUlNq2bav77rtPubm5bmlKS0uVmpqqVq1aKTIyUmPHjtW5c+fc0hQUFOiee+5R8+bN1bZtW82YMUMVFRXBrAoAH37/+9/LZrNp+vTpznWMb6Dh+uc//6mf//znatWqlZo1a6ZevXrpwIEDzu2GYSgjI0Pt27dXs2bNNGLECH322WdueXz11VcaP368oqOjFRsbq8mTJ+vy5cvBrgoAF5WVlXrmmWfUqVMnNWvWTJ07d9azzz4rwzCcaRjfQMOxc+dOjR49WvHx8bLZbFq/fr3b9toaz3//+981dOhQhYeHq0OHDlqwYEFdVw0/QEGbZF6zZo3S09M1a9Ysffzxx+rTp4+Sk5NVVFQUrBAA1NCOHTuUmpqqDz/8UDk5OSovL9fIkSN15coVZ5rf/va3+p//+R+tXbtWO3bs0OnTp3X//fc7t1dWVuqee+5RWVmZPvjgA61atUorV65URkZGfVQJgIn9+/frlVdeUe/evd3WM76BhunChQsaPHiwQkNDtWnTJh0/flwvvPCCWrRo4UyzYMECLV68WC+//LI++ugjRUREKDk5WaWlpc4048eP17Fjx5STk6N33nlHO3fu1JQpU+qjSgC+NX/+fC1btkxLlizRiRMnNH/+fC1YsEDZ2dnONIxvoOG4cuWK+vTpo6VLl5pur43xXFxcrJEjR6pjx446ePCgFi5cqMzMTC1fvrzO64cfGCNIbrvtNiM1NdX5ubKy0oiPjzeysrKCFQKA61RUVGRIMnbs2GEYhmFcvHjRCA0NNdauXetMc+LECUOSsXfvXsMwDGPjxo1GSEiIcfbsWWeaZcuWGdHR0ca1a9eCWwEA1Vy6dMno0qWLkZOTY/zkJz8xfvOb3xiGwfgGGrInn3zSGDJkiOV2h8NhxMXFGQsXLnSuu3jxohEWFmb86U9/MgzDMI4fP25IMvbv3+9Ms2nTJsNmsxn//Oc/6y54AF7dc889xi9/+Uu3dffff78xfvx4wzAY30BDJslYt26d83NtjeeXXnrJaNGihdv9+ZNPPml069atjmsUfCUlJcbx48eNkpKS+g6lUfG3XYPyJHNZWZkOHjyoESNGONeFhIRoxIgR2rt3bzBCAFALvv76a0lSy5YtJUkHDx5UeXm529i++eablZCQ4Bzbe/fuVa9evdSuXTtnmuTkZBUXF+vYsWNBjB6AmdTUVN1zzz1u41hifAMN2YYNGzRgwAD97Gc/U9u2bXXrrbfq1VdfdW7Py8vT2bNn3cZ3TEyMBg0a5Da+Y2NjNWDAAGeaESNGKCQkRB999FHwKgPAze23365t27bp5MmTkqQjR45o9+7dGjVqlCTGN9CY1NZ43rt3r+644w41bdrUmSY5OVm5ubm6cOFCkGqDH4ImwSjkf//3f1VZWen2JVSS2rVrp08//TQYIQC4Tg6HQ9OnT9fgwYPVs2dPSdLZs2fVtGlTxcbGuqVt166dzp4960xjNvartgGoP2+++aY+/vhj7d+/v9o2xjfQcH3xxRdatmyZ0tPT9bvf/U779+/XtGnT1LRpU02YMME5Ps3Gr+v4btu2rdv2Jk2aqGXLloxvoB499dRTKi4u1s033yy73a7Kyko999xzGj9+vCQxvoFGpLbG89mzZ9WpU6dqeVRtc32dFnA9gjLJDKDhS01N1SeffKLdu3fXdygAakFhYaF+85vfKCcnR+Hh4fUdDoBa5HA4NGDAAM2bN0+SdOutt+qTTz7Ryy+/rAkTJtRzdACux1tvvaXVq1frjTfeUI8ePXT48GFNnz5d8fHxjG8AQL0KyiRz69atZbfbq/0i/blz5xQXFxeMEABch7S0NOcPCNx4443O9XFxcSorK9PFixfdnnZ0HdtxcXHat2+fW35V5wLGP1B/Dh48qKKiIvXr18+5rrKyUjt37tSSJUu0ZcsWxjfQQLVv31633HKL27ru3bvrL3/5i6Tvxue5c+fUvn17Z5pz586pb9++zjSeP9BdUVGhr776ivEN1KMZM2boqaee0rhx4yRJvXr10pdffqmsrCxNmDCB8Q00IrU1nuPi4kzn41zLaOz6f9w/qOUd7HfQ77Q2m83r9lmzZikzMzOgOGw2m9atW6f77rsvoP1rKijvZG7atKn69++vbdu2Odc5HA5t27ZNSUlJwQgBQAAMw1BaWprWrVunv/3tb9X+i03//v0VGhrqNrZzc3NVUFDgHNtJSUk6evSo24UvJydH0dHR1b4AAwie4cOH6+jRozp8+LBzGTBggMaPH+/8m/ENNEyDBw9Wbm6u27qTJ0+qY8eOkqROnTopLi7ObXwXFxfro48+chvfFy9e1MGD331J+tvf/iaHw6FBgwYFoRYAzFy9elUhIe5f4+12uxwOhyTGN9CY1NZ4TkpK0s6dO1VeXu5Mk5OTo27duvGqjO+BM2fOOJdFixYpOjrabd3jjz9e3yH6LSiTzJKUnp6uV199VatWrdKJEyf06KOP6sqVK5o0aVKwQgBQQ6mpqXr99df1xhtvKCoqSmfPntXZs2dVUlIi6ZsfHZg8ebLS09P1/vvv6+DBg5o0aZKSkpL04x//WJI0cuRI3XLLLfq3f/s3HTlyRFu2bNHTTz+t1NRUhYWF1Wf1gB+0qKgo9ezZ022JiIhQq1at1LNnT8Y30ID99re/1Ycffqh58+bp888/1xtvvKHly5crNTVV0jdPtUyfPl1z587Vhg0bdPToUf3iF79QfHy880mX7t27KyUlRY888oj27dunPXv2KC0tTePGjVN8fHw91g74YRs9erSee+45vfvuu8rPz9e6dev04osvasyYMZIY30BDc/nyZecDH9I3P/Z3+PBhFRQU1Np4fvjhh9W0aVNNnjxZx44d05o1a/THP/5R6enp9VRruIqLi3MuMTExstlsbuvefPNNde/eXeHh4br55pv10ksvOfctKytTWlqa2rdvr/DwcHXs2FFZWVmSpMTEREnSmDFjZLPZnJ/rUtDeyfzQQw/p/PnzysjI0NmzZ9W3b19t3ry52gvMAXx/LFu2TJI0bNgwt/UrVqzQxIkTJUl/+MMfFBISorFjx+ratWtKTk52O+nZ7Xa98847evTRR5WUlKSIiAhNmDBBc+bMCVY1AASI8Q00TAMHDtS6des0c+ZMzZkzR506ddKiRYucPwwmSU888YSuXLmiKVOm6OLFixoyZIg2b97s9o721atXKy0tTcOHD3eeCxYvXlwfVQLwrezsbD3zzDOaOnWqioqKFB8fr1//+tfKyMhwpmF8Aw3HgQMHdOeddzo/V038TpgwQStXrqyV8RwTE6OtW7cqNTVV/fv3V+vWrZWRkaEpU6YEr6IIyOrVq5WRkaElS5bo1ltv1aFDh/TII484v3ctXrxYGzZs0FtvvaWEhAQVFhaqsLBQkrR//361bdtWK1asUEpKiux2e53HazMMw6jzUgAAAAAAAACgjpSWliovL0+dOnVym4j/Pr+T2dXKlSs1ffp0Xbx4UZJ000036dlnn9W//uu/OtPMnTtXGzdu1AcffKBp06bp2LFjeu+990zf7Vxb72S2aldPQXuSGQAAAAAAAADg3ZUrV3Tq1ClNnjxZjzzyiHN9RUWFYmJiJEkTJ07UXXfdpW7duiklJUU//elPNXLkyPoKmUlmAAAAAAAAAPi+uHz5siTp1VdfrfajrFWvvujXr5/y8vK0adMmvffee3rwwQc1YsQI/fnPfw56vBKTzAAAAAAAAADwvdGuXTvFx8friy++cPtdDU/R0dF66KGH9NBDD+mBBx5QSkqKvvrqK7Vs2VKhoaGqrKwMWsxMMgMAAAAAAADA98js2bM1bdo0xcTEKCUlRdeuXdOBAwd04cIFpaen68UXX1T79u116623KiQkRGvXrlVcXJxiY2MlSYmJidq2bZsGDx6ssLAwtWjRok7jZZIZAAAAAAAAQKMU6A/x1bdf/epXat68uRYuXKgZM2YoIiJCvXr10vTp0yVJUVFRWrBggT777DPZ7XYNHDhQGzduVEhIiCTphRdeUHp6ul599VXdcMMNys/Pr9N4bYZhGHVaAgAAAAAAAADUodLSUuXl5alTp04KDw+v73AaDX/bNSSIMQEAAAAAAAAAGhkmmQEAAAAAAAAAAWOSGQAAAAAAAAAQMCaZAQAAAAAAAAABY5IZAAAAAAAAQKNgGEZ9h9Co+NueTDIDAAAAAAAAaNDsdrskqaysrJ4jaVyuXr0qSQoNDfWarkkwggEAAAAAAACAutKkSRM1b95c58+fV2hoqEJCeLb2ehiGoatXr6qoqEixsbHOSXwrNoNnyAEAAAAAAAA0cGVlZcrLy5PD4ajvUBqN2NhYxcXFyWazeU3HJDMAAAAAAACARsHhcPDKjFoSGhrq8wnmKkwyAwAAAAAAAAACxstJAAAAAAAAAAABY5IZAAAAAAAAABAwJpkBAAAAAAAAAAFjkhkAAAAAAAAAEDAmmQEAAAAAAAAAAWOSGQAAAAAAAAAQMCaZAQAAAAAAAAAB+38FxFbH2jZnCQAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 1600x50 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x50 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x50 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x50 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "o = np.random.randint(0, 2, 1000)\n",
    "for p in [1, .75, .5, .25, .125]:\n",
    "    splits = get_splits(o, train_size=p)\n",
    "    test_eq(len(splits[0]), len(o) * .8 * p)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x50 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "((#60) [58,95,53,44,28,69,9,12,22,88...],\n",
       " (#20) [89,71,60,4,19,37,75,13,46,30...],\n",
       " (#20) [76,68,74,29,16,97,14,21,90,82...])"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = L([0] * 50 + [1] * 25 + [2] * 15 + [3] * 10)\n",
    "splits = get_splits(y, valid_size=.2, test_size=.2)\n",
    "test_eq(np.mean(y[splits[0]])==np.mean(y[splits[1]])==np.mean(y[splits[2]]), True)\n",
    "splits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x50 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "((#60) [0,1,2,3,4,5,6,7,8,9...],\n",
       " (#20) [60,61,62,63,64,65,66,67,68,69...],\n",
       " (#20) [80,81,82,83,84,85,86,87,88,89...])"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y = L([0] * 50 + [1] * 25 + [2] * 15 + [3] * 10)\n",
    "splits = get_splits(y, n_splits=1, valid_size=.2, test_size=.2, shuffle=False)\n",
    "# test_eq(splits[0] + splits[1] + splits[2], np.arange(100))\n",
    "splits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x50 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "splits = get_splits(np.random.randint(0,5,100), valid_size=0.213, test_size=17)\n",
    "test_eq(len(splits[1]), 21)\n",
    "test_eq(len(splits[2]), 17)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABZkAAACJCAYAAABO3TZjAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAlYElEQVR4nO3deXhUVZrH8V8lhITsBAMhShYjS4SwQxpZxAckQWUgYCNjHAkiOEKk6YyodGsSUEiz2TQBFfFpoFsQpBWaadZIswvKIgwKBoTExGYJM7KTkKTqzh801ZQEkipTlUr4fp7nPk/dc8+957237qmqvBzONRmGYQgAAAAAAAAAAAd41HQAAAAAAAAAAIDaiyQzAAAAAAAAAMBhJJkBAAAAAAAAAA4jyQwAAAAAAAAAcBhJZgAAAAAAAACAw0gyAwAAAAAAAAAcRpIZAAAAAAAAAOAwkswAAAAAAAAAAIeRZAYAAAAAAAAAOIwkMwAAgJMsWrRIJpNJ+fn51rLevXurd+/e1d5WZmamTCaTTVlUVJRSUlKqva2fys/Pl8lk0qJFi6xlKSkp8vf3d3rbN5hMJmVmZrqsPQAAAAD/QpIZAADgnw4dOqQnn3xSkZGR8vHx0b333qtHH31U2dnZTmvz5MmTyszM1IEDB5zWhj3Wrl3rtslad44NAAAAuJvVq+kAAAAA3MHnn3+uRx55RBERERo1apTCwsJUWFio3bt36w9/+INeeumlamln48aNNusnT57UpEmTFBUVpfbt21dLGzfk5ubKw8O+MQVr167VvHnz7ErmRkZGqri4WF5eXnZGaJ87xVZcXKx69fhpCwAAANQEfokDAABImjJlioKCgrRnzx4FBwfbbCsqKqq2durXr19tx6qMt7e3U49fXl4ui8Wi+vXry8fHx6ltVaam2wcAAADuZkyXAQAAIOn48eNq3br1LQlmSWrcuLHNuslkUmpqqpYsWaKWLVvKx8dHnTp10rZt2ypt5+Y5mbds2aIuXbpIkkaMGCGTyXTL3MYV2bFjh7p06SIfHx/FxMRo/vz5Fdb76ZzMZWVlmjRpkpo3by4fHx81atRIPXr0UE5OjqTr8yjPmzfPeo43Fulf8y7PnDlTs2fPVkxMjLy9vXX48OEK52S+4cSJE0pISJCfn5/Cw8M1efJkGYZh3b5lyxaZTCZt2bLFZr+fHvNOsd0o++kI56+++kr9+/dXYGCg/P391adPH+3evdumzo15s3fu3Km0tDSFhobKz89PSUlJOnv2bMVvAAAAAAAbjGQGAADQ9Skfdu3apa+//lpt2rSptP7WrVu1fPlyjRs3Tt7e3nrnnXeUmJioL7/8skr7S1JsbKwmT56s9PR0jR49Wj179pQkPfTQQ7fd59ChQ+rXr59CQ0OVmZmp8vJyZWRkqEmTJpW2l5mZqaysLD3//PPq2rWrLl68qL1792r//v169NFH9cILL+jkyZPKycnRn//85wqPsXDhQpWUlGj06NHy9vZWSEiILBZLhXXNZrMSExP1i1/8QtOnT9f69euVkZGh8vJyTZ48uQpX6F+qEtvNvvnmG/Xs2VOBgYF65ZVX5OXlpfnz56t3797aunWr4uPjbeq/9NJLatiwoTIyMpSfn6/Zs2crNTVVy5cvtytOAAAA4G5EkhkAAEDSyy+/rP79+6t9+/bq2rWrevbsqT59+uiRRx6pcK7hr7/+Wnv37lWnTp0kScOGDVPLli2Vnp6uTz/9tEptNmnSRP3791d6erq6deumZ555ptJ90tPTZRiGtm/froiICEnSkCFDFBcXV+m+a9as0WOPPab333+/wu3dunVTixYtlJOTc9tYfvjhB3333XcKDQ21luXn51dYt6SkRImJiZozZ44kacyYMRowYICmTZumcePG6Z577qk0Zntiu9nrr7+usrIy7dixQ/fff78k6dlnn1XLli31yiuvaOvWrTb1GzVqpI0bN1pHR1ssFs2ZM0cXLlxQUFBQleMEAAAA7kZMlwEAACDp0Ucf1a5du/Rv//ZvOnjwoKZPn66EhATde++9Wr169S31u3XrZk0wS1JERIQGDhyoDRs2yGw2OyVGs9msDRs2aNCgQdYEs3R9RHRCQkKl+wcHB+ubb77RsWPHHI5hyJAhNgnmyqSmplpf35hmpLS0VJ999pnDMVTGbDZr48aNGjRokDXBLElNmzbV008/rR07dujixYs2+4wePdpm+o2ePXvKbDbr+++/d1qcAAAAQF1BkhkAAOCfunTpok8//VTnzp3Tl19+qYkTJ+rSpUt68skndfjwYZu6zZs3v2X/Fi1a6OrVq06by/fs2bMqLi6usO2WLVtWuv/kyZN1/vx5tWjRQnFxcZowYYL+53/+x64YoqOjq1zXw8PDJskrXb9G0u1HP1eHs2fP6urVqxVek9jYWFksFhUWFtqU35y0l6SGDRtKks6dO+e0OAEAAIC6giQzAADAT9SvX19dunTR1KlT9e6776qsrEwrVqyo6bB+tl69eun48eP64x//qDZt2uiDDz5Qx44d9cEHH1T5GA0aNKjWmG4ePXwzZ40Gvx1PT88Ky29+SCEAAACAipFkBgAAuIPOnTtLkk6dOmVTXtGUE0ePHpWvr69d00ncLslakdDQUDVo0KDCtnNzc6t0jJCQEI0YMUIfffSRCgsL1bZtW2VmZjoUT2UsFotOnDhhU3b06FFJUlRUlKR/jRg+f/68Tb2KpqmoamyhoaHy9fWt8Jp8++238vDwULNmzap0LAAAAACVI8kMAAAgafPmzRWOWl27dq2kW6ej2LVrl/bv329dLyws1F//+lf169fvtqNiK+Ln5yfp1iRrRTw9PZWQkKBVq1apoKDAWn7kyBFt2LCh0v3/7//+z2bd399fDzzwgK5du+ZQPFUxd+5c62vDMDR37lx5eXmpT58+kqTIyEh5enpq27ZtNvu98847txyrqrF5enqqX79++utf/2ozLceZM2e0dOlS9ejRQ4GBgQ6eEQAAAICfqlfTAQAAALiDl156SVevXlVSUpJatWql0tJSff7551q+fLmioqI0YsQIm/pt2rRRQkKCxo0bJ29vb2tSdNKkSXa1GxMTo+DgYL333nsKCAiQn5+f4uPjbzv38aRJk7R+/Xr17NlTY8aMUXl5ubKzs9W6detK51d+8MEH1bt3b3Xq1EkhISHau3ev/vKXv9g8nO/GwwzHjRunhIQEeXp6atiwYXad0w0+Pj5av369hg8frvj4eK1bt05r1qzRb37zG+to76CgIP3yl79Udna2TCaTYmJi9Le//U1FRUW3HM+e2N566y3l5OSoR48eGjNmjOrVq6f58+fr2rVrmj59ukPnAwAAAKBiJJkBAAAkzZw5UytWrNDatWv1/vvvq7S0VBERERozZoxef/11BQcH29R/+OGH1a1bN02aNEkFBQV68MEHtWjRIrVt29audr28vLR48WJNnDhR//mf/6ny8nItXLjwtknmtm3basOGDUpLS1N6erruu+8+TZo0SadOnao0yTxu3DitXr1aGzdu1LVr1xQZGam33npLEyZMsNYZPHiwXnrpJS1btkwffvihDMNwOMns6emp9evX68UXX9SECRMUEBCgjIwMpaen29TLzs5WWVmZ3nvvPXl7e2vo0KGaMWOG2rRpY1PPnthat26t7du3a+LEicrKypLFYlF8fLw+/PBDxcfHO3Q+AAAAACpmMniaCQAAgF1MJpPGjh1rMxUEAAAAANytmJMZAAAAAAAAAOAwkswAAAAAAAAAAIeRZAYAAAAAAAAAOIwH/wEAANiJR1oAAAAAwL8wkhkAAAAAAAAA4DCSzAAAAAAAAAAAh7l8ugyLxaKTJ08qICBAJpPJ1c0DAAAAAAAAtZphGLp06ZLCw8Pl4cEYUtQ8lyeZT548qWbNmrm6WQAAAAAAAKBOKSws1H333VfTYQCuTzIHBARIkgrnSIENqrbPic5f2dVGysUUO6NyjW1HD9pVP2jUBbvqf/XVCbvqO8KRa7socFG1x3Gz+/d2sHsfe+8pR9gbl73vd7utveyqL9l/D7riOtmrQ4f77d7nwoIgu+q743m7Y99zhCP91V69WrSzq747XidH7nN7OfKdYe/7Vxc+ayXnf7+64neLO97n7vq5Zm9c9sbkjp+DknTw4W121be3XzjyuWZvG+54T7kiJkfuKXvvkbrwG9IR7vi95wr29ldX/B3qCs7+/Jdc8x3gbI7c5674vWYve+9bR947Z/+Nb75i1tePfW3NswE1zeVJ5htTZAQ2kAJ9q7aPvR3G0+Jpb1guUdXzvWkPu2q74oPFkWvr7Ljsv66uuVbOfr89/e1/L+yNyT2/rOy7TlLdOG937HuOcKS/2svevuGO18mR+9xejpy3O/YlZ3/WSs4/D1f8bnHH+9xdP9fsjcvemNzxc/A6Z//udH7fc8d7yhUxOXJP2XuPuOPnvyvcreftjn+HuoKzP/8l13wHOJtrztv9fgs79t45/298SUxFC7fBpC0AAAAAAAAAAIeRZAYAAAAAAAAAOIwkMwAAAAAAAADAYS6fkxkAAAAAAAAAnMFisai0tLSmw6gTvLy85OlZtfnCSTIDAAAAAAAAqPVKS0uVl5cni8VS06HUGcHBwQoLC6v0IZMkmQEAAAAAAADUaoZh6NSpU/L09FSzZs3k4cEswT+HYRi6evWqioqKJElNmza9Y32SzAAAAAAAAABqtfLycl29elXh4eHy9fWt6XDqhAYNGkiSioqK1Lhx4ztOnUFKHwAAAAAAAECtZjabJUn169ev4UjqlhsJ+7KysjvWI8kMAAAAAAAAoE6obO5g2Keq15MkMwAAAAAAAADAYSSZAQAAAAAAAAAO48F/AAAAAAAAAOqk48ePu7S9mJgYu+qnpKRo8eLFysrK0muvvWYtX7VqlZKSkmQYRnWH6BR2j2Tetm2bBgwYoPDwcJlMJq1atcoJYQEAAAAAAABA3efj46Np06bp3LlzNR2Kw+xOMl+5ckXt2rXTvHnznBEPAAAAAAAAANw1+vbtq7CwMGVlZd22zieffKLWrVvL29tbUVFRmjVrls32qKgoTZ06Vc8995wCAgIUERGh999/36ZOYWGhhg4dquDgYIWEhGjgwIHKz8+vlnOwO8ncv39/vfXWW0pKSqqWAAAAAAAAAADgbuXp6ampU6cqOztbP/zwwy3b9+3bp6FDh2rYsGE6dOiQMjMz9cYbb2jRokU29WbNmqXOnTvrq6++0pgxY/Tiiy8qNzdXklRWVqaEhAQFBARo+/bt2rlzp/z9/ZWYmKjS0tKffQ5Of/DftWvXdPHiRZsFAAAAAAAAAHBdUlKS2rdvr4yMjFu2vf322+rTp4/eeOMNtWjRQikpKUpNTdWMGTNs6j322GMaM2aMHnjgAb366qu65557tHnzZknS8uXLZbFY9MEHHyguLk6xsbFauHChCgoKtGXLlp8dv9OTzFlZWQoKCrIuzZo1c3aTAAAAAAAAAFCrTJs2TYsXL9aRI0dsyo8cOaLu3bvblHXv3l3Hjh2T2Wy2lrVt29b62mQyKSwsTEVFRZKkgwcP6rvvvlNAQID8/f3l7++vkJAQlZSUVMvDEev97CNUYuLEiUpLS7OuX7x4kUQzAAAAAAAAANykV69eSkhI0MSJE5WSkmL3/l5eXjbrJpNJFotFknT58mV16tRJS5YsuWW/0NBQh+K9mdOTzN7e3vL29nZ2MwAAAAAAAABQq/3ud79T+/bt1bJlS2tZbGysdu7caVNv586datGihTw9Pat03I4dO2r58uVq3LixAgMDqzVmyQXTZQAAAAAAAAAAKhcXF6fk5GTNmTPHWvZf//Vf2rRpk958800dPXpUixcv1ty5c/Xyyy9X+bjJycm65557NHDgQG3fvl15eXnasmWLxo0bV+HDBu1ld5L58uXLOnDggA4cOCBJysvL04EDB1RQUPCzgwEAAAAAAACAu9nkyZOt01xI10chf/zxx1q2bJnatGmj9PR0TZ482a4pNXx9fbVt2zZFRERo8ODBio2N1ciRI1VSUlItI5vtni5j7969euSRR6zrN+ZbHj58uBYtWvSzAwIAAAAAAACA6hATE1PTIdxRRfnUqKgoXbt2zaZsyJAhGjJkyG2Pk5+ff0vZjUHCN4SFhWnx4sWOhFkpu5PMvXv3lmEYzogFAAAAAAAAAFDLMCczAAAAAAAAAMBhJJkBAAAAAAAAAA4jyQwAAAAAAAAAcBhJZgAAAAAAAACAw0gyAwAAAAAAAAAcRpIZAAAAAAAAAOAwkswAAAAAAAAAAIeRZAYAAAAAAAAAOIwkMwAAAAAAAADUEVFRUZo9e7ZL2yTJDAAAAAAAAKBOMplcu9gXm+mOS2ZmpkPnvGfPHo0ePdqhfR1Vz6WtAQAAAAAAAAB06tQp6+vly5crPT1dubm51jJ/f3/ra8MwZDabVa9e5enc0NDQ6g20ChjJDAAAAAAAAAAuFhYWZl2CgoJkMpms699++60CAgK0bt06derUSd7e3tqxY4eOHz+ugQMHqkmTJvL391eXLl302Wef2Rz3p9NlmEwmffDBB0pKSpKvr6+aN2+u1atXV+u5uHwks2EYkqSLxVXf59KlS3a1Yb5stqu+q1y8avcedtW29zo5wpFre8nDuXHZf11dc62c/X478l7YG5MrrpP97LtOUt04b3fse45wpL/ay95r5Y7XyZH73F6O3Ofu2Jec/VkrOf88XPG7xR3vc3f9XHP2Z4g7fg5e5+zfnc7ve+54T7kiJkfuKXvjcsfPf1e4W8/bHf8OdQVX/IZ0xXeAs7niN6Q7/hZ27L1z7t/45ivX69/Is6Hueu211zRz5kzdf//9atiwoQoLC/XYY49pypQp8vb21p/+9CcNGDBAubm5ioiIuO1xJk2apOnTp2vGjBnKzs5WcnKyvv/+e4WEhFRPoIaLHT9+3JDEwsLCwsLCwsLCwsLCwsLCwsLC8jOW48ePuzq157aKi4uNw4cPG8XFxTblkmsXRy1cuNAICgqyrm/evNmQZKxatarSfVu3bm1kZ2db1yMjI43f//73N10DGa+//rp1/fLly4YkY926dZUe+3bX9adcPpL5Rna8oKBAQUFBrm4egBNdvHhRzZo1U2FhoQIDA2s6HADViP4N1F30b6Duon8DddeFCxcUERFRfaNQ4bY6d+5ss3758mVlZmZqzZo1OnXqlMrLy1VcXKyCgoI7Hqdt27bW135+fgoMDFRRUVG1xenyJLOHx/VpoIOCgviSA+qowMBA+jdQR9G/gbqL/g3UXfRvoO66kWdD3eXn52ez/vLLLysnJ0czZ87UAw88oAYNGujJJ59UaWnpHY/j5eVls24ymWSxWKotTpcnmQEAAAAAAAAA9tu5c6dSUlKUlJQk6frI5vz8/JoNShL/3AEAAAAAAAAAtUDz5s316aef6sCBAzp48KCefvrpah2R7CiXJ5m9vb2VkZEhb29vVzcNwMno30DdRf8G6i76N1B30b+Buov+ffd6++231bBhQz300EMaMGCAEhIS1LFjx5oOS6Z/PmEQAAAAAAAAAGqlkpIS5eXlKTo6Wj4+PjUdTp1R1evKdBkAAAAAAAAAAIeRZAYAAAAAAAAAOIwkMwAAAAAAAADAYSSZAQAAAAAAAAAOc2mSed68eYqKipKPj4/i4+P15ZdfurJ5ANUgKytLXbp0UUBAgBo3bqxBgwYpNzfXpk5JSYnGjh2rRo0ayd/fX0OGDNGZM2dqKGIAjvrd734nk8mk8ePHW8vo30Dt9Y9//EPPPPOMGjVqpAYNGiguLk579+61bjcMQ+np6WratKkaNGigvn376tixYzUYMYCqMJvNeuONNxQdHa0GDRooJiZGb775pgzDsNahfwO1w7Zt2zRgwACFh4fLZDJp1apVNtur0pd//PFHJScnKzAwUMHBwRo5cqQuX77swrPA3cplSebly5crLS1NGRkZ2r9/v9q1a6eEhAQVFRW5KgQA1WDr1q0aO3asdu/erZycHJWVlalfv366cuWKtc6vf/1r/fd//7dWrFihrVu36uTJkxo8eHANRg3AXnv27NH8+fPVtm1bm3L6N1A7nTt3Tt27d5eXl5fWrVunw4cPa9asWWrYsKG1zvTp0zVnzhy99957+uKLL+Tn56eEhASVlJTUYOQAKjNt2jS9++67mjt3ro4cOaJp06Zp+vTpys7OttahfwO1w5UrV9SuXTvNmzevwu1V6cvJycn65ptvlJOTo7/97W/atm2bRo8e7apTwN3McJGuXbsaY8eOta6bzWYjPDzcyMrKclUIAJygqKjIkGRs3brVMAzDOH/+vOHl5WWsWLHCWufIkSOGJGPXrl01FSYAO1y6dMlo3ry5kZOTYzz88MPGr371K8Mw6N9Abfbqq68aPXr0uO12i8VihIWFGTNmzLCWnT9/3vD29jY++ugjV4QIwEGPP/648dxzz9mUDR482EhOTjYMg/4N1FaSjJUrV1rXq9KXDx8+bEgy9uzZY62zbt06w2QyGf/4xz9cFntNKS4uNg4fPmwUFxfXdCh1SlWvq0tGMpeWlmrfvn3q27evtczDw0N9+/bVrl27XBECACe5cOGCJCkkJESStG/fPpWVldn091atWikiIoL+DtQSY8eO1eOPP27TjyX6N1CbrV69Wp07d9Yvf/lLNW7cWB06dNCCBQus2/Py8nT69Gmb/h0UFKT4+Hj6N+DmHnroIW3atElHjx6VJB08eFA7duxQ//79JdG/gbqiKn15165dCg4OVufOna11+vbtKw8PD33xxRcujxl3l3quaOR///d/ZTab1aRJE5vyJk2a6Ntvv3VFCACcwGKxaPz48erevbvatGkjSTp9+rTq16+v4OBgm7pNmjTR6dOnayBKAPZYtmyZ9u/frz179tyyjf4N1F4nTpzQu+++q7S0NP3mN7/Rnj17NG7cONWvX1/Dhw+39uGKfq/TvwH39tprr+nixYtq1aqVPD09ZTabNWXKFCUnJ0sS/RuoI6rSl0+fPq3GjRvbbK9Xr55CQkLo73A6lz74D0DdMnbsWH399ddatmxZTYcCoBoUFhbqV7/6lZYsWSIfH5+aDgdANbJYLOrYsaOmTp2qDh06aPTo0Ro1apTee++9mg4NwM/08ccfa8mSJVq6dKn279+vxYsXa+bMmVq8eHFNhwYAcIHevXvbPKw9KipKs2fPvuM+FT1Y8udyyUjme+65R56enrc8ff7MmTMKCwtzRQgAqllqaqr1IQL33XeftTwsLEylpaU6f/68zWhH+jvg/vbt26eioiJ17NjRWmY2m7Vt2zbNnTtXGzZsoH8DtVTTpk314IMP2pTFxsbqk08+kSRrHz5z5oyaNm1qrXPmzBm1b9/eZXECsN+ECRP02muvadiwYZKkuLg4ff/998rKytLw4cPp30AdUZW+HBYWpqKiIpv9ysvL9eOPP97dv9eXmlzb3tNGlasOGDBAZWVlWr9+/S3btm/frl69eungwYO3PJD9Tvbs2SM/P78q168uLhnJXL9+fXXq1EmbNm2yllksFm3atEndunVzRQgAqolhGEpNTdXKlSv197//XdHR0TbbO3XqJC8vL5v+npubq4KCAvo74Ob69OmjQ4cO6cCBA9alc+fOSk5Otr6mfwO1U/fu3ZWbm2tTdvToUUVGRkqSoqOjFRYWZtO/L168qC+++IL+Dbi5q1evysPD9k97T09PWSwWSfRvoK6oSl/u1q2bzp8/r3379lnr/P3vf5fFYlF8fLzLY0blRo4cqZycHP3www+3bFu4cKE6d+5sV4JZkkJDQ+Xr61tdIVaZy6bLSEtL04IFC7R48WIdOXJEL774oq5cuaIRI0a4KgQA1WDs2LH68MMPtXTpUgUEBOj06dM6ffq0iouLJV1/8MDIkSOVlpamzZs3a9++fRoxYoS6deumX/ziFzUcPYA7CQgIUJs2bWwWPz8/NWrUSG3atKF/A7XYr3/9a+3evVtTp07Vd999p6VLl+r999/X2LFjJV3/L5Pjx4/XW2+9pdWrV+vQoUN69tlnFR4erkGDBtVs8ADuaMCAAZoyZYrWrFmj/Px8rVy5Um+//baSkpIk0b+B2uTy5cvWwR7S9Yf9HThwQAUFBVXqy7GxsUpMTNSoUaP05ZdfaufOnUpNTdWwYcMUHh5ecyeG23riiScUGhqqRYsW2ZRfvnxZK1as0KBBg/Tv//7vuvfee+Xr66u4uDh99NFHdzzmT6fLOHbsmHr16iUfHx89+OCDysnJccKZuGi6DEl66qmndPbsWaWnp+v06dNq37691q9ff8uE5QDc27vvvivp+pw/N1u4cKFSUlIkSb///e/l4eGhIUOG6Nq1a0pISNA777zj4kgBOAP9G6idunTpopUrV2rixImaPHmyoqOjNXv2bOuDwSTplVde0ZUrVzR69GidP39ePXr00Pr165mjHXBz2dnZeuONNzRmzBgVFRUpPDxcL7zwgtLT06116N9A7bB371498sgj1vW0tDRJ0vDhw7Vo0aIq9eUlS5YoNTVVffr0sf5unzNnjsvPBVVTr149Pfvss1q0aJF++9vfymS6PrXHihUrZDab9cwzz2jFihV69dVXFRgYqDVr1ug//uM/FBMTo65du1Z6fIvFosGDB6tJkyb64osvdOHCBZv5m6uTyTCMqk8UAgAAAAAAAABupqSkRHl5eYqOjrb9RzQ3npNZkr799lvFxsZq8+bN1gF9vXr1UmRkpP785z/fUv+JJ55Qq1atNHPmTEnXBwG2b9/eOno5KipK48eP1/jx47Vx40Y9/vjj+v77762j2devX6/+/ftr5cqVVfofLbe9rj/hsukyAAAAAAAAAAD/0qpVKz300EP64x//KEn67rvvtH37do0cOVJms1lvvvmm4uLiFBISIn9/f23YsEEFBQVVOvaRI0fUrFkzm+lSnDUfP0lmAAAAAAAAAKghI0eO1CeffKJLly5p4cKFiomJ0cMPP6wZM2boD3/4g1599VVt3rxZBw4cUEJCgkpLS2s65FuQZAYAAAAAAACAGjJ06FB5eHho6dKl+tOf/qTnnntOJpNJO3fu1MCBA/XMM8+oXbt2uv/++3X06NEqHzc2NlaFhYU6deqUtWz37t3OOAWSzAAAAAAAAABQU/z9/fXUU09p4sSJOnXqlFJSUiRJzZs3V05Ojj7//HMdOXJEL7zwgs6cOVPl4/bt21ctWrTQ8OHDdfDgQW3fvl2//e1vnXIOJJkBAAAAAAAAoAaNHDlS586dU0JCgnUO5ddff10dO3ZUQkKCevfurbCwsCo9rO8GDw8PrVy5UsXFxeratauef/55TZkyxSnxmwzDsO+RhwAAAAAAAADgRkpKSpSXl6fo6Gj5+PjUdDh1RlWvKyOZAQAAAAAAAAAOI8kMAAAAAAAAAHAYSWYAAAAAAAAAgMNIMgMAAAAAAAAAHEaSGQAAAAAAAADgMJLMAAAAAAAAAACHkWQGAAAAAAAAADiMJDMAAAAAAAAAwGEkmQEAAAAAAAAADiPJDAAAAAAAAABwWL2aDgAAAAAAAAAAnKHT/k4ubW9fx31Vrmsyme64PSMjQ5mZmQ7FYTKZtHLlSg0aNMih/e1FkhkAAAAAAAAAXOzUqVPW18uXL1d6erpyc3OtZf7+/jURlkOYLgMAAAAAAAAAXCwsLMy6BAUFyWQy2ZQtW7ZMsbGx8vHxUatWrfTOO+9Y9y0tLVVqaqqaNm0qHx8fRUZGKisrS5IUFRUlSUpKSpLJZLKuOxMjmQEAAAAAAADAjSxZskTp6emaO3euOnTooK+++kqjRo2Sn5+fhg8frjlz5mj16tX6+OOPFRERocLCQhUWFkqS9uzZo8aNG2vhwoVKTEyUp6en0+MlyQwAAAAAAAAAbiQjI0OzZs3S4MGDJUnR0dE6fPiw5s+fr+HDh6ugoEDNmzdXjx49ZDKZFBkZad03NDRUkhQcHKywsDCXxEuSGQAAAAAAAADcxJUrV3T8+HGNHDlSo0aNspaXl5crKChIkpSSkqJHH31ULVu2VGJiop544gn169evpkImyQwAAAAAAAAA7uLy5cuSpAULFig+Pt5m242pLzp27Ki8vDytW7dOn332mYYOHaq+ffvqL3/5i8vjlUgyAwAAAAAAAIDbaNKkicLDw3XixAklJyfftl5gYKCeeuopPfXUU3ryySeVmJioH3/8USEhIfLy8pLZbHZZzCSZAQAAAAAAAMCNTJo0SePGjVNQUJASExN17do17d27V+fOnVNaWprefvttNW3aVB06dJCHh4dWrFihsLAwBQcHS5KioqK0adMmde/eXd7e3mrYsKFT4yXJDAAAAAAAAKBO2tdxX02H4JDnn39evr6+mjFjhiZMmCA/Pz/FxcVp/PjxkqSAgABNnz5dx44dk6enp7p06aK1a9fKw8NDkjRr1iylpaVpwYIFuvfee5Wfn+/UeE2GYRhObQEAAAAAAAAAnKikpER5eXmKjo6Wj49PTYdTZ1T1unq4MCYAAAAAAAAAQB1DkhkAAAAAAAAA4DCSzAAAAAAAAAAAh5FkBgAAAAAAAAA4jCQzAAAAAAAAgDrBMIyaDqFOqer1JMkMAAAAAAAAoFbz9PSUJJWWltZwJHXL1atXJUleXl53rFfPFcEAAAAAAAAAgLPUq1dPvr6+Onv2rLy8vOThwdjan8MwDF29elVFRUUKDg62JvFvx2QwhhwAAAAAAABALVdaWqq8vDxZLJaaDqXOCA4OVlhYmEwm0x3rkWQGAAAAAAAAUCdYLBamzKgmXl5elY5gvoEkMwAAAAAAAADAYUxOAgAAAAAAAABwGElmAAAAAAAAAIDDSDIDAAAAAAAAABxGkhkAAAAAAAAA4DCSzAAAAAAAAAAAh5FkBgAAAAAAAAA4jCQzAAAAAAAAAMBh/w8kGQb7+hTd/QAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 1600x50 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "text/plain": [
       "((#12) [37,38,62,60,16,22,95,44,94,98...],\n",
       " (#21) [88,93,5,31,57,23,90,18,15,40...],\n",
       " (#17) [4,86,47,33,59,52,99,48,70,3...])"
      ]
     },
     "execution_count": null,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "splits = get_splits(np.random.randint(0,5,100), valid_size=0.213, test_size=17, train_size=.2)\n",
    "splits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def get_predefined_splits(*xs):\n",
    "    '''xs is a list with X_train, X_valid, ...'''\n",
    "    splits_ = []\n",
    "    start = 0\n",
    "    for x in xs:\n",
    "        splits_.append(L(list(np.arange(start, start + len(x)))))\n",
    "        start += len(x)\n",
    "    return tuple(splits_)\n",
    "\n",
    "def combine_split_data(xs, ys=None):\n",
    "    '''xs is a list with X_train, X_valid, .... ys is None or a list with y_train, y_valid, .... '''\n",
    "    xs = [to3d(x) for x in xs]\n",
    "    splits = get_predefined_splits(*xs)\n",
    "    if ys is None: return concat(*xs), None, splits\n",
    "    else: return concat(*xs), concat(*ys), splits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def get_splits_len(splits):\n",
    "    _len = []\n",
    "    for split in splits:\n",
    "        if isinstance(split[0], (list, L, tuple)):  _len.append([len(s) for s in split])\n",
    "        else: _len.append(len(split))\n",
    "    return _len"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, y_train, X_valid, y_valid = np.random.rand(3,3,4), np.random.randint(0,2,3), np.random.rand(2,3,4), np.random.randint(0,2,2)\n",
    "X, y, splits = combine_split_data([X_train, X_valid], [y_train, y_valid])\n",
    "test_eq(X_train, X[splits[0]])\n",
    "test_eq(X_valid, X[splits[1]])\n",
    "test_type(X_train, X)\n",
    "test_type(y_train, y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X_train, y_train, X_valid, y_valid = np.random.rand(3,4), np.random.randint(0,2,3), np.random.rand(2,4), np.random.randint(0,2,2)\n",
    "X, y, splits = combine_split_data([X_train, X_valid], [y_train, y_valid])\n",
    "test_eq(X_train[:, None], X[splits[0]])\n",
    "test_eq(X_valid[:, None], X[splits[1]])\n",
    "test_type(X_train, X)\n",
    "test_type(y_train, y)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Forecasting"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def get_usable_idxs(df, fcst_history, fcst_horizon, stride=1):\n",
    "    if len(df) < fcst_history + fcst_horizon:\n",
    "        return np.array([], dtype=int)\n",
    "    usable_idxs = df[fcst_history - 1:len(df) - fcst_horizon].index.values\n",
    "    if stride != 1:\n",
    "        usable_idxs = usable_idxs[::-stride][::-1]\n",
    "    return usable_idxs\n",
    "\n",
    "\n",
    "def get_df_usable_idxs(\n",
    "    df,                         # dataframe containing a sorted time series\n",
    "    fcst_history,               # # historical steps used as input (size of the sliding window for the input)\n",
    "    fcst_horizon,               # # steps forecasted into the future (size of the sliding window for the target)\n",
    "    stride=1,                   # int or tuple of 2 int containing the strides of the sliding windows (input and target)\n",
    "    unique_id_cols=None,        # str indicating the column/s with the unique identifier/s for each entity\n",
    "    return_np_indices=False,    # bool indicating what type of indices are returned. Default to False (dataframe indices)\n",
    "):\n",
    "    \"Calculates the indices that can be used from a df when using a sliding window\"\n",
    "\n",
    "    dtype = smallest_dtype(len(df))\n",
    "    if unique_id_cols is not None:\n",
    "        usable_df_idxs = np.sort(np.concatenate(df\n",
    "                                                .reset_index(drop=True)\n",
    "                                                .groupby(unique_id_cols)\n",
    "                                                .apply(lambda x: get_usable_idxs(x,\n",
    "                                                                                 fcst_history=fcst_history,\n",
    "                                                                                 fcst_horizon=fcst_horizon,\n",
    "                                                                                 stride=stride\n",
    "                                                                                )).values, dtype=dtype))\n",
    "    else:\n",
    "        usable_df_idxs = np.sort(get_usable_idxs(df, fcst_history, fcst_horizon, stride).astype(dtype=dtype))\n",
    "    if return_np_indices:\n",
    "        usable_df_idxs = usable_df_idxs - (fcst_history - 1)\n",
    "    return usable_df_idxs\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def calculate_fcst_stats(\n",
    "    df, # dataframe containing a sorted time series for a single entity or subject\n",
    "    fcst_history, # # historical steps used as input.\n",
    "    fcst_horizon, # # steps forecasted into the future.\n",
    "    splits, # splits that will be used to train the model. splits[0] is the train split:\n",
    "    x_vars=None, # features used as input\n",
    "    y_vars=None,  # features used as output\n",
    "    subset_size=None, # int or float to determne the number of train samples used to calculate the mean and std\n",
    "):\n",
    "    \"Calculates the training stats required in a forecasting task\"\n",
    "    x_vars = list(df.columns) if x_vars is None else feat2list(x_vars)\n",
    "    y_vars = list(df.columns) if y_vars is None else feat2list(y_vars)\n",
    "    split = splits[0] if is_listy(splits[0]) else splits\n",
    "    if fcst_history == 1:\n",
    "        train_idxs = split\n",
    "    else:\n",
    "\n",
    "        if subset_size is None:\n",
    "            idxs = split\n",
    "        else:\n",
    "            subset = int(subset_size) if isinstance(subset_size, Integral) else int(subset_size * len(split))\n",
    "            idxs = random_choice(idxs, subset, replace=False)\n",
    "        dtype = smallest_dtype(max(split) + fcst_history)\n",
    "        train_idxs = np.unique((np.asarray(idxs, dtype=dtype).reshape(-1,1) + np.arange(fcst_history, dtype=dtype).reshape(1, -1)).flatten())\n",
    "    mean = df.reset_index().loc[train_idxs, x_vars].mean().values.reshape(1, -1, 1)\n",
    "    std  = df.reset_index().loc[train_idxs, x_vars].std().values.reshape(1, -1, 1)\n",
    "    if x_vars == y_vars:\n",
    "        return (mean, std)\n",
    "    y_mean = df.reset_index().loc[train_idxs, y_vars].mean().values.reshape(1, -1, 1)\n",
    "    y_std  = df.reset_index().loc[train_idxs, y_vars].std().values.reshape(1, -1, 1)\n",
    "    return (mean, std), (y_mean, y_std)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def get_forecasting_splits(\n",
    "    df,                         # dataframe containing a sorted time series\n",
    "    fcst_history,               # # historical steps used as input (size of the sliding window for the input)\n",
    "    fcst_horizon,               # # steps forecasted into the future (size of the sliding window for the target)\n",
    "    stride=1,                   # int or tuple of 2 int containing the strides of the sliding windows (input and target)\n",
    "    valid_size=0.,              # int or float indicating the size of the training set (based on datetimes)\n",
    "    test_size=0.2,              # int or float indicating the size of the test set (based on datetimes)\n",
    "    valid_cutoff_datetime=None, # first prediction datetime of validation dataset\n",
    "    test_cutoff_datetime=None,  # first prediction datetime of test dataset\n",
    "    datetime_col=None,          # str indicating the column with the datetime values\n",
    "    use_index=False,            # flag to indicate if the datetime is in the index\n",
    "    unique_id_cols=None,        # str indicating the column/s with the unique identifier/s for each entity\n",
    "    show_plot=True,             # flag to indicate if splits should be plotted\n",
    "):\n",
    "\n",
    "    if unique_id_cols or valid_cutoff_datetime is not None or test_cutoff_datetime is not None:\n",
    "        assert datetime_col is not None or use_index, \\\n",
    "        \"you need to pass a datetime_col or set use_index=False to be able to access datetime\"\n",
    "\n",
    "    if valid_cutoff_datetime is not None or test_cutoff_datetime is not None:\n",
    "        valid_size = 0\n",
    "        test_size = 0\n",
    "\n",
    "    use_valid = valid_cutoff_datetime is not None or valid_size != 0\n",
    "    use_test = test_cutoff_datetime is not None or test_size != 0\n",
    "\n",
    "    if valid_cutoff_datetime is not None:\n",
    "        valid_cutoff_datetime = np.datetime64(valid_cutoff_datetime)\n",
    "    if test_cutoff_datetime is not None:\n",
    "        test_cutoff_datetime = np.datetime64(test_cutoff_datetime)\n",
    "\n",
    "    if use_index:\n",
    "        datetime_col = 'index' if df.index.name is None else df.index.name\n",
    "        df = df.reset_index(drop=False)[feat2list(datetime_col) + feat2list(unique_id_cols)]\n",
    "    elif datetime_col is not None:\n",
    "        df = df[feat2list(datetime_col) + feat2list(unique_id_cols)]\n",
    "    else:\n",
    "        df = df.reset_index(drop=True)\n",
    "        if unique_id_cols is not None:\n",
    "            df = df[feat2list(unique_id_cols)]\n",
    "\n",
    "    usable_df_idxs = get_df_usable_idxs(df, fcst_history, fcst_horizon, stride=stride, unique_id_cols=unique_id_cols)\n",
    "    usable_np_idxs = usable_df_idxs - (fcst_history - 1)\n",
    "\n",
    "    if datetime_col is not None:\n",
    "        usable_steps = pd.to_datetime(df.loc[usable_df_idxs, datetime_col])\n",
    "        cat = usable_steps.astype('category').cat\n",
    "        usable_step_codes = cat.codes.values\n",
    "    else:\n",
    "        usable_step_codes = np.arange(len(usable_df_idxs))\n",
    "\n",
    "\n",
    "    # test indices\n",
    "    if test_cutoff_datetime is not None:\n",
    "        test_start = np.argmax(cat.categories >= test_cutoff_datetime)\n",
    "        test_idxs = usable_np_idxs[usable_step_codes >= test_start]\n",
    "    elif test_size:\n",
    "        if test_size < 1:\n",
    "            if unique_id_cols is None:\n",
    "                n_usable_steps = len(usable_step_codes) - (fcst_horizon - 1) * (int(valid_size > 0) + int(test_size > 0))\n",
    "            else:\n",
    "                n_usable_steps = len(usable_step_codes)\n",
    "            test_size = round(n_usable_steps * test_size)\n",
    "        test_start = np.sort(usable_step_codes)[- test_size]\n",
    "        test_idxs = usable_np_idxs[usable_step_codes >= test_start]\n",
    "    else:\n",
    "        test_idxs = np.array([])\n",
    "    test_size = len(test_idxs)\n",
    "\n",
    "    # valid indices\n",
    "    if valid_cutoff_datetime is not None:\n",
    "        valid_start =  np.argmax(cat.categories >= valid_cutoff_datetime)\n",
    "        if test_cutoff_datetime is not None:\n",
    "            valid_end = test_start - (fcst_horizon - 1) // stride\n",
    "            assert valid_start <= valid_end, \"you need to modify valid_size and/or test_size due to lack of data\"\n",
    "            valid_idxs = usable_np_idxs[(usable_step_codes >= valid_start) & (usable_step_codes < valid_end)]\n",
    "        else:\n",
    "            valid_idxs = usable_np_idxs[(usable_step_codes >= valid_start)]\n",
    "    elif valid_size:\n",
    "        if valid_size < 1:\n",
    "            if unique_id_cols is None:\n",
    "                n_usable_steps = len(usable_step_codes) - (fcst_horizon - 1) * (int(valid_size > 0) + int(test_size > 0))\n",
    "            else:\n",
    "                n_usable_steps = len(usable_step_codes)\n",
    "            valid_size = round(n_usable_steps * valid_size)\n",
    "        if test_size:\n",
    "            valid_end = test_start - (fcst_horizon - 1) // stride\n",
    "            remaining_usable_step_codes = usable_step_codes[usable_step_codes < valid_end]\n",
    "            valid_start = np.sort(remaining_usable_step_codes)[- valid_size]\n",
    "            assert 0 < valid_start <= valid_end <= test_start, \"you need to modify valid_size and/or test_size due to lack of data\"\n",
    "            valid_idxs = usable_np_idxs[(usable_step_codes >= valid_start) & (usable_step_codes < valid_end)]\n",
    "        else:\n",
    "            valid_start = np.sort(usable_step_codes)[- valid_size]\n",
    "            valid_idxs = usable_np_idxs[usable_step_codes >= valid_start]\n",
    "    else:\n",
    "        valid_idxs = np.array([])\n",
    "    valid_size = len(valid_idxs)\n",
    "\n",
    "    # train indices\n",
    "    if use_valid:\n",
    "        train_end = valid_start - (fcst_horizon - 1) // stride\n",
    "        assert train_end > 0, \"you need to modify valid_size due to lack of data\"\n",
    "        train_idxs = usable_np_idxs[usable_step_codes < train_end]\n",
    "    elif use_test:\n",
    "        train_end = test_start - (fcst_horizon - 1) // stride\n",
    "        assert train_end > 0, \"you need to modify test_size due to lack of data\"\n",
    "        train_idxs = usable_np_idxs[usable_step_codes < train_end]\n",
    "    else:\n",
    "        train_idxs = usable_np_idxs\n",
    "    train_size = len(train_idxs)\n",
    "\n",
    "\n",
    "    if len(df) < 1_000_000:\n",
    "        train_idxs = L(train_idxs.tolist())\n",
    "        if len(valid_idxs):\n",
    "            valid_idxs = L(valid_idxs.tolist())\n",
    "        if len(test_idxs):\n",
    "            test_idxs = L(test_idxs.tolist())\n",
    "\n",
    "    splits = (train_idxs,)\n",
    "    if valid_size:\n",
    "        splits += (valid_idxs,)\n",
    "    if test_size:\n",
    "        splits += (test_idxs,)\n",
    "\n",
    "    if show_plot:\n",
    "        if len(df) > 1_000_000:\n",
    "            warnings.warn('the splits are too large to be plotted')\n",
    "        else:\n",
    "            plot_splits(splits)\n",
    "    return tuple(splits)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>value</th>\n",
       "      <th>datetime</th>\n",
       "      <th>type</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>1749-03-31</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>1749-04-01</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>1749-04-02</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>1749-04-03</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4</td>\n",
       "      <td>1749-04-04</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>95</th>\n",
       "      <td>95</td>\n",
       "      <td>1749-07-04</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>96</th>\n",
       "      <td>96</td>\n",
       "      <td>1749-07-05</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>97</th>\n",
       "      <td>97</td>\n",
       "      <td>1749-07-06</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>98</th>\n",
       "      <td>98</td>\n",
       "      <td>1749-07-07</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>99</th>\n",
       "      <td>99</td>\n",
       "      <td>1749-07-08</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>100 rows × 3 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "    value   datetime  type\n",
       "0       0 1749-03-31     1\n",
       "1       1 1749-04-01     1\n",
       "2       2 1749-04-02     1\n",
       "3       3 1749-04-03     1\n",
       "4       4 1749-04-04     1\n",
       "..    ...        ...   ...\n",
       "95     95 1749-07-04     1\n",
       "96     96 1749-07-05     1\n",
       "97     97 1749-07-06     1\n",
       "98     98 1749-07-07     1\n",
       "99     99 1749-07-08     1\n",
       "\n",
       "[100 rows x 3 columns]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x50 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "splits size   : [63, 9, 18] (90: [0.7, 0.1, 0.2])\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x50 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "splits size   : [12, 2, 4] (18: [0.67, 0.11, 0.22])\n"
     ]
    }
   ],
   "source": [
    "df1_len = 100\n",
    "df2_len = 80\n",
    "\n",
    "datetime_col = 'datetime'\n",
    "df1 = pd.DataFrame(np.arange(df1_len), columns=['value'])\n",
    "df1['datetime'] = pd.date_range(pd.to_datetime('1749-03-31'), periods=df1_len, freq='1D')\n",
    "df1['type'] = 1\n",
    "\n",
    "df = df1\n",
    "display(df)\n",
    "\n",
    "# settings\n",
    "fcst_history          = 10\n",
    "fcst_horizon          = 1\n",
    "stride                = 1\n",
    "unique_id_cols        = 'type'\n",
    "datetime_col          = 'datetime'\n",
    "use_index             = False\n",
    "valid_size            = 0.1  # a percent (float) or a number of samples (int) - .1 means 10% of the dates\n",
    "test_size             = 0.2  # a percent (float) or a number of samples (int) - .1 means 10% of the dates\n",
    "valid_cutoff_datetime = '1749-08-21' # first prediction datetime of validation dataset\n",
    "test_cutoff_datetime  = '1749-12-24' # first prediction datetime of test dataset\n",
    "valid_cutoff_datetime = None # datetime compatible with the datetime_col containing the starting date for the validation dataset\n",
    "test_cutoff_datetime  = None # datetime compatible with the datetime_col containing the starting date for the validation dataset\n",
    "\n",
    "\n",
    "splits = get_forecasting_splits(df, fcst_history=fcst_history, fcst_horizon=fcst_horizon, stride=stride,\n",
    "                                unique_id_cols=unique_id_cols, datetime_col=datetime_col, use_index=use_index,\n",
    "                                valid_size=valid_size, test_size=test_size,\n",
    "                                valid_cutoff_datetime=valid_cutoff_datetime, test_cutoff_datetime=test_cutoff_datetime)\n",
    "\n",
    "print(f\"splits size   : {[len(s) for s in splits]} ({sum([len(s) for s in splits])}: {[round(len(s)/sum([len(s) for s in splits]), 2) for s in splits]})\")\n",
    "\n",
    "# settings\n",
    "fcst_history          = 10\n",
    "fcst_horizon          = 5\n",
    "stride                = 5\n",
    "unique_id_cols        = 'type'\n",
    "datetime_col          = 'datetime'\n",
    "use_index             = False\n",
    "valid_size            = 0.1  # a percent (float) or a number of samples (int) - .1 means 10% of the dates\n",
    "test_size             = 0.2  # a percent (float) or a number of samples (int) - .1 means 10% of the dates\n",
    "valid_cutoff_datetime = '1749-08-21' # first prediction datetime of validation dataset\n",
    "test_cutoff_datetime  = '1749-12-24' # first prediction datetime of test dataset\n",
    "valid_cutoff_datetime = None # datetime compatible with the datetime_col containing the starting date for the validation dataset\n",
    "test_cutoff_datetime  = None # datetime compatible with the datetime_col containing the starting date for the validation dataset\n",
    "\n",
    "\n",
    "splits = get_forecasting_splits(df, fcst_history=fcst_history, fcst_horizon=fcst_horizon, stride=stride,\n",
    "                                unique_id_cols=unique_id_cols, datetime_col=datetime_col, use_index=use_index,\n",
    "                                valid_size=valid_size, test_size=test_size,\n",
    "                                valid_cutoff_datetime=valid_cutoff_datetime, test_cutoff_datetime=test_cutoff_datetime)\n",
    "\n",
    "print(f\"splits size   : {[len(s) for s in splits]} ({sum([len(s) for s in splits])}: {[round(len(s)/sum([len(s) for s in splits]), 2) for s in splits]})\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>value</th>\n",
       "      <th>type</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>datetime</th>\n",
       "      <th></th>\n",
       "      <th></th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1749-03-31</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1749-04-01</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1749-04-02</th>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1749-04-03</th>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1749-04-04</th>\n",
       "      <td>4</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1749-07-04</th>\n",
       "      <td>95</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1749-07-05</th>\n",
       "      <td>96</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1749-07-06</th>\n",
       "      <td>97</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1749-07-07</th>\n",
       "      <td>98</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1749-07-08</th>\n",
       "      <td>99</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>100 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "            value  type\n",
       "datetime               \n",
       "1749-03-31      0     1\n",
       "1749-04-01      1     1\n",
       "1749-04-02      2     1\n",
       "1749-04-03      3     1\n",
       "1749-04-04      4     1\n",
       "...           ...   ...\n",
       "1749-07-04     95     1\n",
       "1749-07-05     96     1\n",
       "1749-07-06     97     1\n",
       "1749-07-07     98     1\n",
       "1749-07-08     99     1\n",
       "\n",
       "[100 rows x 2 columns]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x50 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "splits size   : [63, 9, 18] (90: [0.7, 0.1, 0.2])\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x50 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "splits size   : [12, 2, 4] (18: [0.67, 0.11, 0.22])\n"
     ]
    }
   ],
   "source": [
    "df1_len = 100\n",
    "df2_len = 80\n",
    "\n",
    "datetime_col = 'datetime'\n",
    "df1 = pd.DataFrame(np.arange(df1_len), columns=['value'])\n",
    "df1['datetime'] = pd.date_range(pd.to_datetime('1749-03-31'), periods=df1_len, freq='1D')\n",
    "df1['type'] = 1\n",
    "df1_index = df1.set_index(\"datetime\")\n",
    "\n",
    "df = df1_index\n",
    "display(df)\n",
    "\n",
    "# settings\n",
    "fcst_history          = 10\n",
    "fcst_horizon          = 1\n",
    "stride                = 1\n",
    "unique_id_cols        = 'type'\n",
    "datetime_col          = 'datetime'\n",
    "use_index             = True\n",
    "valid_size            = 0.1  # a percent (float) or a number of samples (int) - .1 means 10% of the dates\n",
    "test_size             = 0.2  # a percent (float) or a number of samples (int) - .1 means 10% of the dates\n",
    "valid_cutoff_datetime = '1749-08-21' # first prediction datetime of validation dataset\n",
    "test_cutoff_datetime  = '1749-12-24' # first prediction datetime of test dataset\n",
    "valid_cutoff_datetime = None # datetime compatible with the datetime_col containing the starting date for the validation dataset\n",
    "test_cutoff_datetime  = None # datetime compatible with the datetime_col containing the starting date for the validation dataset\n",
    "\n",
    "\n",
    "splits = get_forecasting_splits(df, fcst_history=fcst_history, fcst_horizon=fcst_horizon, stride=stride,\n",
    "                                unique_id_cols=unique_id_cols, datetime_col=datetime_col, use_index=use_index,\n",
    "                                valid_size=valid_size, test_size=test_size,\n",
    "                                valid_cutoff_datetime=valid_cutoff_datetime, test_cutoff_datetime=test_cutoff_datetime)\n",
    "\n",
    "print(f\"splits size   : {[len(s) for s in splits]} ({sum([len(s) for s in splits])}: {[round(len(s)/sum([len(s) for s in splits]), 2) for s in splits]})\")\n",
    "\n",
    "# settings\n",
    "fcst_history          = 10\n",
    "fcst_horizon          = 5\n",
    "stride                = 5\n",
    "unique_id_cols        = 'type'\n",
    "datetime_col          = 'datetime'\n",
    "use_index             = True\n",
    "valid_size            = 0.1  # a percent (float) or a number of samples (int) - .1 means 10% of the dates\n",
    "test_size             = 0.2  # a percent (float) or a number of samples (int) - .1 means 10% of the dates\n",
    "valid_cutoff_datetime = '1749-08-21' # first prediction datetime of validation dataset\n",
    "test_cutoff_datetime  = '1749-12-24' # first prediction datetime of test dataset\n",
    "valid_cutoff_datetime = None # datetime compatible with the datetime_col containing the starting date for the validation dataset\n",
    "test_cutoff_datetime  = None # datetime compatible with the datetime_col containing the starting date for the validation dataset\n",
    "\n",
    "\n",
    "splits = get_forecasting_splits(df, fcst_history=fcst_history, fcst_horizon=fcst_horizon, stride=stride,\n",
    "                                unique_id_cols=unique_id_cols, datetime_col=datetime_col, use_index=use_index,\n",
    "                                valid_size=valid_size, test_size=test_size,\n",
    "                                valid_cutoff_datetime=valid_cutoff_datetime, test_cutoff_datetime=test_cutoff_datetime)\n",
    "\n",
    "print(f\"splits size   : {[len(s) for s in splits]} ({sum([len(s) for s in splits])}: {[round(len(s)/sum([len(s) for s in splits]), 2) for s in splits]})\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>value</th>\n",
       "      <th>datetime</th>\n",
       "      <th>type</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0</td>\n",
       "      <td>1749-03-31</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>1</td>\n",
       "      <td>1749-04-01</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2</td>\n",
       "      <td>1749-04-02</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>1749-04-03</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>4</td>\n",
       "      <td>1749-04-04</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>175</th>\n",
       "      <td>750</td>\n",
       "      <td>1749-06-29</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>176</th>\n",
       "      <td>760</td>\n",
       "      <td>1749-06-30</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>177</th>\n",
       "      <td>770</td>\n",
       "      <td>1749-07-01</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>178</th>\n",
       "      <td>780</td>\n",
       "      <td>1749-07-02</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>179</th>\n",
       "      <td>790</td>\n",
       "      <td>1749-07-03</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>180 rows × 3 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     value   datetime  type\n",
       "0        0 1749-03-31     1\n",
       "1        1 1749-04-01     1\n",
       "2        2 1749-04-02     1\n",
       "3        3 1749-04-03     1\n",
       "4        4 1749-04-04     1\n",
       "..     ...        ...   ...\n",
       "175    750 1749-06-29     2\n",
       "176    760 1749-06-30     2\n",
       "177    770 1749-07-01     2\n",
       "178    780 1749-07-02     2\n",
       "179    790 1749-07-03     2\n",
       "\n",
       "[180 rows x 3 columns]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x50 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "splits size   : [101, 16, 31] (148: [0.68, 0.11, 0.21])\n"
     ]
    }
   ],
   "source": [
    "df1_len = 100\n",
    "df2_len = 80\n",
    "\n",
    "datetime_col = 'datetime'\n",
    "df1 = pd.DataFrame(np.arange(df1_len), columns=['value'])\n",
    "df1['datetime'] = pd.date_range(pd.to_datetime('1749-03-31'), periods=df1_len, freq='1D')\n",
    "df1['type'] = 1\n",
    "df1_index = df1.set_index(\"datetime\")\n",
    "df2 = pd.DataFrame(np.arange(df2_len) * 10, columns=['value'])\n",
    "df2['datetime'] = pd.date_range(pd.to_datetime('1749-04-15'), periods=df2_len, freq='1D')\n",
    "df2['type'] = 2\n",
    "df_comb = pd.concat([df1, df2]).reset_index(drop=True).reset_index(drop=True)\n",
    "\n",
    "\n",
    "df = df_comb\n",
    "display(df)\n",
    "\n",
    "# settings\n",
    "fcst_history          = 10\n",
    "fcst_horizon          = 3\n",
    "stride                = 1\n",
    "unique_id_cols        = 'type'\n",
    "datetime_col          = 'datetime'\n",
    "use_index             = False\n",
    "valid_size            = 0.1  # a percent (float) or a number of samples (int) - .1 means 10% of the dates\n",
    "test_size             = 0.2  # a percent (float) or a number of samples (int) - .1 means 10% of the dates\n",
    "valid_cutoff_datetime = '1749-08-21' # first prediction datetime of validation dataset\n",
    "test_cutoff_datetime  = '1749-12-24' # first prediction datetime of test dataset\n",
    "valid_cutoff_datetime = None # datetime compatible with the datetime_col containing the starting date for the validation dataset\n",
    "test_cutoff_datetime  = None # datetime compatible with the datetime_col containing the starting date for the validation dataset\n",
    "\n",
    "\n",
    "splits = get_forecasting_splits(df, fcst_history=fcst_history, fcst_horizon=fcst_horizon, stride=stride,\n",
    "                                unique_id_cols=unique_id_cols, datetime_col=datetime_col, use_index=use_index,\n",
    "                                valid_size=valid_size, test_size=test_size,\n",
    "                                valid_cutoff_datetime=valid_cutoff_datetime, test_cutoff_datetime=test_cutoff_datetime)\n",
    "\n",
    "print(f\"splits size   : {[len(s) for s in splits]} ({sum([len(s) for s in splits])}: {[round(len(s)/sum([len(s) for s in splits]), 2) for s in splits]})\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>value</th>\n",
       "      <th>type</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>1749-03-31</th>\n",
       "      <td>0</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1749-04-01</th>\n",
       "      <td>1</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1749-04-02</th>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1749-04-03</th>\n",
       "      <td>3</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1749-04-04</th>\n",
       "      <td>4</td>\n",
       "      <td>1</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1749-06-29</th>\n",
       "      <td>750</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1749-06-30</th>\n",
       "      <td>760</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1749-07-01</th>\n",
       "      <td>770</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1749-07-02</th>\n",
       "      <td>780</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1749-07-03</th>\n",
       "      <td>790</td>\n",
       "      <td>2</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>180 rows × 2 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "            value  type\n",
       "1749-03-31      0     1\n",
       "1749-04-01      1     1\n",
       "1749-04-02      2     1\n",
       "1749-04-03      3     1\n",
       "1749-04-04      4     1\n",
       "...           ...   ...\n",
       "1749-06-29    750     2\n",
       "1749-06-30    760     2\n",
       "1749-07-01    770     2\n",
       "1749-07-02    780     2\n",
       "1749-07-03    790     2\n",
       "\n",
       "[180 rows x 2 columns]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1600x50 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "splits size   : [83, 14, 29] (126: [0.66, 0.11, 0.23])\n"
     ]
    }
   ],
   "source": [
    "df1_len = 100\n",
    "df2_len = 80\n",
    "\n",
    "datetime_col = 'datetime'\n",
    "df1 = pd.DataFrame(np.arange(df1_len), columns=['value'])\n",
    "df1['datetime'] = pd.date_range(pd.to_datetime('1749-03-31'), periods=df1_len, freq='1D')\n",
    "df1['type'] = 1\n",
    "df1_index = df1.set_index(\"datetime\")\n",
    "df2 = pd.DataFrame(np.arange(df2_len) * 10, columns=['value'])\n",
    "df2['datetime'] = pd.date_range(pd.to_datetime('1749-04-15'), periods=df2_len, freq='1D')\n",
    "df2['type'] = 2\n",
    "df_comb = pd.concat([df1, df2]).reset_index(drop=True).reset_index(drop=True)\n",
    "df_comb_index = df_comb.set_index(\"datetime\")\n",
    "df_comb_index.index.name = None\n",
    "\n",
    "\n",
    "df = df_comb_index\n",
    "display(df)\n",
    "\n",
    "# settings\n",
    "fcst_history          = 15\n",
    "fcst_horizon          = 5\n",
    "stride                = 1\n",
    "unique_id_cols        = 'type'\n",
    "datetime_col          = 'datetime'\n",
    "use_index             = True\n",
    "valid_size            = 0.1  # a percent (float) or a number of samples (int) - .1 means 10% of the dates\n",
    "test_size             = 0.2  # a percent (float) or a number of samples (int) - .1 means 10% of the dates\n",
    "valid_cutoff_datetime = '1749-08-21' # first prediction datetime of validation dataset\n",
    "test_cutoff_datetime  = '1749-12-24' # first prediction datetime of test dataset\n",
    "valid_cutoff_datetime = None # datetime compatible with the datetime_col containing the starting date for the validation dataset\n",
    "test_cutoff_datetime  = None # datetime compatible with the datetime_col containing the starting date for the validation dataset\n",
    "\n",
    "\n",
    "splits = get_forecasting_splits(df, fcst_history=fcst_history, fcst_horizon=fcst_horizon, stride=stride,\n",
    "                                unique_id_cols=unique_id_cols, datetime_col=datetime_col, use_index=use_index,\n",
    "                                valid_size=valid_size, test_size=test_size,\n",
    "                                valid_cutoff_datetime=valid_cutoff_datetime, test_cutoff_datetime=test_cutoff_datetime)\n",
    "\n",
    "print(f\"splits size   : {[len(s) for s in splits]} ({sum([len(s) for s in splits])}: {[round(len(s)/sum([len(s) for s in splits]), 2) for s in splits]})\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#|export\n",
    "def get_long_term_forecasting_splits(\n",
    "    df, # dataframe containing a sorted time series for a single entity or subject\n",
    "    fcst_history,   # # historical steps used as input.\n",
    "    fcst_horizon,   # # steps forecasted into the future.\n",
    "    dsid=None,      # dataset name\n",
    "    show_plot=True, # plot the splits\n",
    "):\n",
    "    \"Returns the train, valid and test splits for long-range time series datasets\"\n",
    "\n",
    "    if dsid in [\"ETTh1\", \"ETTh2\"]:\n",
    "        border1s = [0, 12 * 30 * 24 - fcst_history, 12 * 30 * 24 + 4 * 30 * 24 - fcst_history]\n",
    "        border2s = [12 * 30 * 24, 12 * 30 * 24 + 4 * 30 * 24, 12 * 30 * 24 + 8 * 30 * 24]\n",
    "    elif dsid in [\"ETTm1\", \"ETTm2\"]:\n",
    "        border1s = [0, 12 * 30 * 24 * 4 - fcst_history, 12 * 30 * 24 * 4 + 4 * 30 * 24 * 4 - fcst_history]\n",
    "        border2s = [12 * 30 * 24 * 4, 12 * 30 * 24 * 4 + 4 * 30 * 24 * 4, 12 * 30 * 24 * 4 + 8 * 30 * 24 * 4]\n",
    "    else:\n",
    "        train_size = .7 # default 0.7\n",
    "        test_size = .2 # default 0.2\n",
    "        num_train = int(len(df) * train_size)\n",
    "        num_test = int(len(df) * test_size)\n",
    "        num_vali = len(df) - num_train - num_test\n",
    "        assert num_train + num_test + num_vali <= len(df)\n",
    "        border1s = [0, num_train - fcst_history, len(df) - num_test - fcst_history]\n",
    "        border2s = [num_train, num_train + num_vali, len(df)]\n",
    "\n",
    "    train_split = L(np.arange(border1s[0], border2s[0] - fcst_horizon - fcst_history + 1).tolist())\n",
    "    valid_split = L(np.arange(border1s[1], border2s[1] - fcst_horizon - fcst_history + 1).tolist())\n",
    "    test_split = L(np.arange(border1s[2], border2s[2] - fcst_horizon - fcst_history + 1).tolist())\n",
    "    splits = train_split, valid_split, test_split\n",
    "    if show_plot:\n",
    "        plot_splits(splits)\n",
    "    return splits"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/javascript": "IPython.notebook.save_checkpoint();",
      "text/plain": [
       "<IPython.core.display.Javascript object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/Users/nacho/notebooks/tsai/nbs/003_data.validation.ipynb saved at 2023-07-01 12:22:02\n",
      "Correct notebook to script conversion! 😃\n",
      "Saturday 01/07/23 12:22:05 CEST\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "                <audio  controls=\"controls\" autoplay=\"autoplay\">\n",
       "                    <source src=\"data:audio/wav;base64,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\" type=\"audio/wav\" />\n",
       "                    Your browser does not support the audio element.\n",
       "                </audio>\n",
       "              "
      ],
      "text/plain": [
       "<IPython.lib.display.Audio object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#|eval: false\n",
    "#|hide\n",
    "from tsai.export import get_nb_name; nb_name = get_nb_name(locals())\n",
    "from tsai.imports import create_scripts; create_scripts(nb_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "python3",
   "language": "python",
   "name": "python3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
